anchor.diff:  
           let typeQualifierParser: Parser<TypeQualifier, _> = many1 singleTypeQualifier
       
  +    module TypeSpecifierParser =
  +        let typeSpecifierNonArray =
  +            TokensParsers.Keyword._void
  +            <|> TokensParsers.Keyword._float
  +            <|> TokensParsers.Keyword._double
  +            <|> TokensParsers.Keyword._int
  +            <|> TokensParsers.Keyword._uint
  +            <|> TokensParsers.Keyword._bool
  +            <|> TokensParsers.Keyword._vec2
  +            <|> TokensParsers.Keyword._vec3
  +            <|> TokensParsers.Keyword._vec4
  +            <|> TokensParsers.Keyword._dvec2
  +            <|> TokensParsers.Keyword._dvec3
  +            <|> TokensParsers.Keyword._dvec4
  +            <|> TokensParsers.Keyword._bvec2
  +            <|> TokensParsers.Keyword._bvec3
  +            <|> TokensParsers.Keyword._bvec4
  +            <|> TokensParsers.Keyword._ivec2
  +            <|> TokensParsers.Keyword._ivec3
  +            <|> TokensParsers.Keyword._ivec4
  +            <|> TokensParsers.Keyword._uvec2
  +            <|> TokensParsers.Keyword._uvec3
  +            <|> TokensParsers.Keyword._uvec4
  +            <|> TokensParsers.Keyword._mat2
  +            <|> TokensParsers.Keyword._mat3
  +            <|> TokensParsers.Keyword._mat4
  +            <|> TokensParsers.Keyword._mat2x2
  +            <|> TokensParsers.Keyword._mat2x3
  +            <|> TokensParsers.Keyword._mat2x4
  +            <|> TokensParsers.Keyword._mat3x2
  +            <|> TokensParsers.Keyword._mat3x3
  +            <|> TokensParsers.Keyword._mat3x4
  +            <|> TokensParsers.Keyword._mat4x2
  +            <|> TokensParsers.Keyword._mat4x3
  +            <|> TokensParsers.Keyword._mat4x4
  +            <|> TokensParsers.Keyword._dmat2
  +            <|> TokensParsers.Keyword._dmat3
  +            <|> TokensParsers.Keyword._dmat4
  +            <|> TokensParsers.Keyword._dmat2x2
  +            <|> TokensParsers.Keyword._dmat2x3
  +            <|> TokensParsers.Keyword._dmat2x4
  +            <|> TokensParsers.Keyword._dmat3x2
  +            <|> TokensParsers.Keyword._dmat3x3
  +            <|> TokensParsers.Keyword._dmat3x4
  +            <|> TokensParsers.Keyword._dmat4x2
  +            <|> TokensParsers.Keyword._dmat4x3
  +            <|> TokensParsers.Keyword._dmat4x4
  +            <|> TokensParsers.Keyword._atomic_uint
  +            <|> TokensParsers.Keyword._sampler2D
  +            <|> TokensParsers.Keyword._sampler3D
  +            <|> TokensParsers.Keyword._samplerCube
  +            <|> TokensParsers.Keyword._sampler2DShadow
  +            <|> TokensParsers.Keyword._samplerCubeShadow
  +            <|> TokensParsers.Keyword._sampler2DArray
  +            <|> TokensParsers.Keyword._sampler2DArrayShadow
  +            <|> TokensParsers.Keyword._samplerCubeArray
  +            <|> TokensParsers.Keyword._samplerCubeArrayShadow
  +            <|> TokensParsers.Keyword._isampler2D
  +            <|> TokensParsers.Keyword._isampler3D
  +            <|> TokensParsers.Keyword._isamplerCube
  +            <|> TokensParsers.Keyword._isampler2DArray
  +            <|> TokensParsers.Keyword._isamplerCubeArray
  +            <|> TokensParsers.Keyword._usampler2D
  +            <|> TokensParsers.Keyword._usampler3D
  +            <|> TokensParsers.Keyword._usamplerCube
  +            <|> TokensParsers.Keyword._usampler2DArray
  +            <|> TokensParsers.Keyword._usamplerCubeArray
  +            <|> TokensParsers.Keyword._sampler1D
  +            <|> TokensParsers.Keyword._sampler1DShadow
  +            <|> TokensParsers.Keyword._sampler1DArray
  +            <|> TokensParsers.Keyword._sampler1DArrayShadow
  +            <|> TokensParsers.Keyword._isampler1D
  +            <|> TokensParsers.Keyword._isampler1DArray
  +            <|> TokensParsers.Keyword._usampler1D
  +            <|> TokensParsers.Keyword._usampler1DArray
  +            <|> TokensParsers.Keyword._sampler2DRect
  +            <|> TokensParsers.Keyword._sampler2DRectShadow
  +            <|> TokensParsers.Keyword._isampler2DRect
  +            <|> TokensParsers.Keyword._usampler2DRect
  +            <|> TokensParsers.Keyword._samplerBuffer
  +            <|> TokensParsers.Keyword._isamplerBuffer
  +            <|> TokensParsers.Keyword._usamplerBuffer
  +            <|> TokensParsers.Keyword._sampler2DMS
  +            <|> TokensParsers.Keyword._isampler2DMS
  +            <|> TokensParsers.Keyword._usampler2DMS
  +            <|> TokensParsers.Keyword._sampler2DMSArray
  +            <|> TokensParsers.Keyword._isampler2DMSArray
  +            <|> TokensParsers.Keyword._usampler2DMSArray
  +            <|> TokensParsers.Keyword._image2D
  +            <|> TokensParsers.Keyword._iimage2D
  +            <|> TokensParsers.Keyword._uimage2D
  +            <|> TokensParsers.Keyword._image3D
  +            <|> TokensParsers.Keyword._iimage3D
  +            <|> TokensParsers.Keyword._uimage3D
  +            <|> TokensParsers.Keyword._imageCube
  +            <|> TokensParsers.Keyword._iimageCube
  +            <|> TokensParsers.Keyword._uimageCube
  +            <|> TokensParsers.Keyword._imageBuffer
  +            <|> TokensParsers.Keyword._iimageBuffer
  +            <|> TokensParsers.Keyword._uimageBuffer
  +            <|> TokensParsers.Keyword._image1D
  +            <|> TokensParsers.Keyword._iimage1D
  +            <|> TokensParsers.Keyword._uimage1D
  +            <|> TokensParsers.Keyword._image1DArray
  +            <|> TokensParsers.Keyword._iimage1DArray
  +            <|> TokensParsers.Keyword._uimage1DArray
  +            <|> TokensParsers.Keyword._image2DRect
  +            <|> TokensParsers.Keyword._iimage2DRect
  +            <|> TokensParsers.Keyword._uimage2DRect
  +            <|> TokensParsers.Keyword._image2DArray
  +            <|> TokensParsers.Keyword._iimage2DArray
  +            <|> TokensParsers.Keyword._uimage2DArray
  +            <|> TokensParsers.Keyword._imageCubeArray
  +            <|> TokensParsers.Keyword._iimageCubeArray
  +            <|> TokensParsers.Keyword._uimageCubeArray
  +            <|> TokensParsers.Keyword._image2DMS
  +            <|> TokensParsers.Keyword._iimage2DMS
  +            <|> TokensParsers.Keyword._uimage2DMS
  +            <|> TokensParsers.Keyword._image2DMSArray
  +            <|> TokensParsers.Keyword._iimage2DMSArray
  +            <|> TokensParsers.Keyword._uimage2DMSArray
  +
  +        let constantExpression = preturn () //TODO:
  +        
  +        let singleArraySpecifier =
  +            (TokensParsers.lBracket .>> TokensParsers.rBracket >>. preturn ())
  +            <|> (TokensParsers.lBracket .>> constantExpression .>> TokensParsers.rBracket >>. preturn ())
  +        
  +        let arraySpecifier =
  +            many1 singleArraySpecifier
  +        
  +        ()
  +    
       let functionDefinition = preturn FunctionDefinition //TODO: To parse uniforms this can probably be skipped
       
       module Declaration =
  
positive.code:         | Keyword of Keyword
          | LParens
          | RParens
      and TypeQualifier = SingleTypeQualifier list
      and SingleTypeQualifier =
          | StorageQualifier of Token //TODO: Can be narrowed to actual storage qualifiers
  
negative.code:             let _readonly = keywordP "readonly" Readonly
              let _writeonly = keywordP "writeonly" Writeonly
              let _subroutine = keywordP "subroutine" Subroutine
  
              let _attribute = keywordP "attribute" Attribute
              let _varying = keywordP "varying" Varying
              let _atomic_uint = keywordP "atomic_uint" Atomic_uint
              let _layout = keywordP "layout" Layout
              let _flat = keywordP "flat" Flat
              let _smooth = keywordP "smooth" Smooth
              let _noperspective = keywordP "noperspective" Noperspective
              let _invariant = keywordP "invariant" Invariant
              let _precise = keywordP "precise" Precise
              let _break = keywordP "break" Break
              let _continue = keywordP "continue" Continue
              let _do = keywordP "do" Do
              let _for = keywordP "for" For
              let _while = keywordP "while" While
              let _switch = keywordP "switch" Switch
              let _case = keywordP "case" Case
              let _default = keywordP "default" Default
              let _if = keywordP "if" If
              let _else = keywordP "else" Else
              let _int = keywordP "int" Int
              let _void = keywordP "void" Void
              let _bool = keywordP "bool" Bool
              let _true = keywordP "true" True
              let _false = keywordP "false" False
              let _float = keywordP "float" Float
              let _double = keywordP "double" Double
              let _discard = keywordP "discard" Discard
              let _return = keywordP "return" Return
              let _vec2 = keywordP "vec2" Vec2
              let _vec3 = keywordP "vec3" Vec3
              let _vec4 = keywordP "vec4" Vec4
              let _ivec2 = keywordP "ivec2" Ivec2
              let _ivec3 = keywordP "ivec3" Ivec3
              let _ivec4 = keywordP "ivec4" Ivec4
              let _bvec2 = keywordP "bvec2" Bvec2
              let _bvec3 = keywordP "bvec3" Bvec3
              let _bvec4 = keywordP "bvec4" Bvec4
              let _uint = keywordP "uint" Uint
              let _uvec2 = keywordP "uvec2" Uvec2
              let _uvec3 = keywordP "uvec3" Uvec3
              let _uvec4 = keywordP "uvec4" Uvec4
              let _dvec2 = keywordP "dvec2" Dvec2
              let _dvec3 = keywordP "dvec3" Dvec3
              let _dvec4 = keywordP "dvec4" Dvec4
              let _mat2 = keywordP "mat2" Mat2
              let _mat3 = keywordP "mat3" Mat3
              let _mat4 = keywordP "mat4" Mat4
              let _mat2x2 = keywordP "mat2x2" Mat2x2
              let _mat2x3 = keywordP "mat2x3" Mat2x3
              let _mat2x4 = keywordP "mat2x4" Mat2x4
              let _mat3x2 = keywordP "mat3x2" Mat3x2
              let _mat3x3 = keywordP "mat3x3" Mat3x3
              let _mat3x4 = keywordP "mat3x4" Mat3x4
              let _mat4x2 = keywordP "mat4x2" Mat4x2
              let _mat4x3 = keywordP "mat4x3" Mat4x3
              let _mat4x4 = keywordP "mat4x4" Mat4x4
              let _dmat2 = keywordP "dmat2" Dmat2
              let _dmat3 = keywordP "dmat3" Dmat3
              let _dmat4 = keywordP "dmat4" Dmat4
              let _dmat2x2 = keywordP "dmat2x2" Dmat2x2
              let _dmat2x3 = keywordP "dmat2x3" Dmat2x3
              let _dmat2x4 = keywordP "dmat2x4" Dmat2x4
              let _dmat3x2 = keywordP "dmat3x2" Dmat3x2
              let _dmat3x3 = keywordP "dmat3x3" Dmat3x3
              let _dmat3x4 = keywordP "dmat3x4" Dmat3x4
              let _dmat4x2 = keywordP "dmat4x2" Dmat4x2
              let _dmat4x3 = keywordP "dmat4x3" Dmat4x3
              let _dmat4x4 = keywordP "dmat4x4" Dmat4x4
              let _lowp = keywordP "lowp" Lowp
              let _mediump = keywordP "mediump" Mediump
              let _highp = keywordP "highp" Highp
              let _precision = keywordP "precision" Precision
              let _sampler1D = keywordP "sampler1D" Sampler1D
              let _sampler1DShadow = keywordP "sampler1DShadow" Sampler1DShadow
              let _sampler1DArray = keywordP "sampler1DArray" Sampler1DArray
              let _sampler1DArrayShadow = keywordP "sampler1DArrayShadow" Sampler1DArrayShadow
              let _isampler1D = keywordP "isampler1D" Isampler1D
              let _isampler1DArray = keywordP "isampler1DArray" Isampler1DArray
              let _usampler1D = keywordP "usampler1D" Usampler1D
              let _usampler1DArray = keywordP "usampler1DArray" Usampler1DArray
              let _sampler2D = keywordP "sampler2D" Sampler2D
              let _sampler2DShadow = keywordP "sampler2DShadow" Sampler2DShadow
              let _sampler2DArray = keywordP "sampler2DArray" Sampler2DArray
              let _sampler2DArrayShadow = keywordP "sampler2DArrayShadow" Sampler2DArrayShadow
              let _isampler2D = keywordP "isampler2D" Isampler2D
              let _isampler2DArray = keywordP "isampler2DArray" Isampler2DArray
              let _usampler2D = keywordP "usampler2D" Usampler2D
              let _usampler2DArray = keywordP "usampler2DArray" Usampler2DArray
              let _sampler2DRect = keywordP "sampler2DRect" Sampler2DRect
              let _sampler2DRectShadow = keywordP "sampler2DRectShadow" Sampler2DRectShadow
              let _isampler2DRect = keywordP "isampler2DRect" Isampler2DRect
              let _usampler2DRect = keywordP "usampler2DRect" Usampler2DRect
              let _sampler2DMS = keywordP "sampler2DMS" Sampler2DMS
              let _isampler2DMS = keywordP "isampler2DMS" Isampler2DMS
              let _usampler2DMS = keywordP "usampler2DMS" Usampler2DMS
              let _sampler2DMSArray = keywordP "sampler2DMSArray" Sampler2DMSArray
              let _isampler2DMSArray = keywordP "isampler2DMSArray" Isampler2DMSArray
              let _usampler2DMSArray = keywordP "usampler2DMSArray" Usampler2DMSArray
              let _sampler3D = keywordP "sampler3D" Sampler3D
              let _isampler3D = keywordP "isampler3D" Isampler3D
              let _usampler3D = keywordP "usampler3D" Usampler3D
              let _samplerCube = keywordP "samplerCube" SamplerCube
              let _samplerCubeShadow = keywordP "samplerCubeShadow" SamplerCubeShadow
              let _isamplerCube = keywordP "isamplerCube" IsamplerCube
              let _usamplerCube = keywordP "usamplerCube" UsamplerCube
              let _samplerCubeArray = keywordP "samplerCubeArray" SamplerCubeArray
              let _samplerCubeArrayShadow = keywordP "samplerCubeArrayShadow" SamplerCubeArrayShadow
              let _isamplerCubeArray = keywordP "isamplerCubeArray" IsamplerCubeArray
              let _usamplerCubeArray = keywordP "usamplerCubeArray" UsamplerCubeArray
              let _samplerBuffer = keywordP "samplerBuffer" SamplerBuffer
              let _isamplerBuffer = keywordP "isamplerBuffer" IsamplerBuffer
              let _usamplerBuffer = keywordP "usamplerBuffer" UsamplerBuffer
              let _image1D = keywordP "image1D" Image1D
              let _iimage1D = keywordP "iimage1D" Iimage1D
              let _uimage1D = keywordP "uimage1D" Uimage1D
              let _image1DArray = keywordP "image1DArray" Image1DArray
              let _iimage1DArray = keywordP "iimage1DArray" Iimage1DArray
              let _uimage1DArray = keywordP "uimage1DArray" Uimage1DArray
              let _image2D = keywordP "image2D" Image2D
              let _iimage2D = keywordP "iimage2D" Iimage2D
              let _uimage2D = keywordP "uimage2D" Uimage2D
              let _image2DArray = keywordP "image2DArray" Image2DArray
              let _iimage2DArray = keywordP "iimage2DArray" Iimage2DArray
              let _uimage2DArray = keywordP "uimage2DArray" Uimage2DArray
              let _image2DRect = keywordP "image2DRect" Image2DRect
              let _iimage2DRect = keywordP "iimage2DRect" Iimage2DRect
              let _uimage2DRect = keywordP "uimage2DRect" Uimage2DRect
              let _image2DMS = keywordP "image2DMS" Image2DMS
              let _iimage2DMS = keywordP "iimage2DMS" Iimage2DMS
              let _uimage2DMS = keywordP "uimage2DMS" Uimage2DMS
              let _image2DMSArray = keywordP "image2DMSArray" Image2DMSArray
              let _iimage2DMSArray = keywordP "iimage2DMSArray" Iimage2DMSArray
              let _uimage2DMSArray = keywordP "uimage2DMSArray" Uimage2DMSArray
              let _image3D = keywordP "image3D" Image3D
              let _iimage3D = keywordP "iimage3D" Iimage3D
              let _uimage3D = keywordP "uimage3D" Uimage3D
              let _imageCube = keywordP "imageCube" ImageCube
              let _iimageCube = keywordP "iimageCube" IimageCube
              let _uimageCube = keywordP "uimageCube" UimageCube
              let _imageCubeArray = keywordP "imageCubeArray" ImageCubeArray
              let _iimageCubeArray = keywordP "iimageCubeArray" IimageCubeArray
              let _uimageCubeArray = keywordP "uimageCubeArray" UimageCubeArray
              let _imageBuffer = keywordP "imageBuffer" ImageBuffer
              let _iimageBuffer = keywordP "iimageBuffer" IimageBuffer
              let _uimageBuffer = keywordP "uimageBuffer" UimageBuffer
              let _struct = keywordP "struct" Struct
      
                      
      let typeNameList endP = many1Till anyChar endP
      
      
      
      module StorageQualifierParser =
          let storageQualifier =
  