h&1ص.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                         ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " " " " " " " " " " " " " # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % & & & & & & & & & & & & & & & & & & & & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + + + + + + + + + + + + + + + + + + + , - . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / //////0000000000000000000111111111111111111111111111111111111111111111112222222222222222222223333333333333333333333334444444444444444444444444445555555555555555556666666666666666777888888888888888888999999999999999999999999:::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<======>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAABBBCCCCCCCCCCCCCCCCCCDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIJKLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNOOOOOPPPQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSTTTTTTTTTTTTTTTTTUUUUUUUVWWWXXXXXXYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^____________________________________________`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbccccccccccccdeeeeeeeeeeeeeeeeeeeeffffffffffffggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiijkkkkkkkllllllllmmmmmmnnnnoooooooooppppppppqqrrrrrrrrrrrrrrsssssssssssssttttttttttuuuvvwwwxxxxxxxyyzzzzzzzzzzzzzz{{{{{{{{|||}}~~~                                                                                                                                !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------..................................................... Safe-Inferred}futharkAST metrics are simply a collection from identifiable node names to the number of times that node appears. None p futhark"A manifest for a compiled program.futharkA mapping from Futhark entry points to how they are represented in C.futharkA mapping from Futhark type name to how they are represented at the C level. Should not contain any of the primitive scalar types. For array types, these have empty dimensions, e.g. []i32.futhark8The compiler backend used to compile the program, e.g. c.futharkManifest info for a non-scalar type. Scalar types are not part of the manifest for a program.futharkctype, Futhark elemtype, rank.futharkThe names of the C functions implementing the operations on some opaque type.futharkThe names of the C functions implementing the operations on some array type.futhark!Manifest info for an entry point.futhark.Manifest info for an entry point return value.futhark+Manifest info for an entry point parameter.futharkSerialise a manifest in JSON format, so it can be read from other tools. The schema supposed to be at  -https://futhark-lang.org/manifest.schema.json."" Nonefuthark&Whether an option accepts an argument.futharkThe . becomes part of the help text.futharkSpecification if a single command line option. The option must have a long name, and may also have a short name.In the action, the option argument (if any) is stored as in the char*-typed variable optarg.futharkGenerate an option parser as a function of the given name, that accepts the given command line options. The result is a function that should be called with argc and argv'. The function returns the number of argv# elements that have been processed.If option parsing fails for any reason, the entire process will terminate with error code 1.   NoneJfuthark rtsc atomics.hfuthark rtsc chaselev.hfuthark rtsccuda.hfuthark rtsc free_list.hfuthark rtschalf.hfuthark rtsclock.hfuthark rtscopencl.hfuthark rtsc scalar_f16.hfuthark rtscscalar.hfuthark rtsc scheduler.hfuthark rtscserver.hfuthark rtsctiming.hfuthark rtsctuning.hfuthark rtscutil.hfuthark rtscvalues.h None1futhark rts javascript server.jsfuthark rts javascript values.jsfuthark rts javascriptwrapperclasses.js Nonesfuthark rtspython memory.pyfuthark rtspython opencl.pyfuthark rtspythonpanic.pyfuthark rtspython scalar.pyfuthark rtspython server.pyfuthark rtspython tuning.pyfuthark rtspython values.py Safe-Inferred futharkA mapping from package paths to their chosen revisions. This is the result of the version solver.futharkA structure corresponding to a  futhark.pkg file, including comments. It is an invariant that duplicate required packages do not occcur (the parser will verify this).futharkThe name of the package.futharkAn entry in the required section of a  futhark.pkg file.futharkName of the required package.futharkThe minimum revision.futharkAn optional hash indicating what this revision looked like the last time we saw it. Used for integrity checking.futharkWraps a value with an annotation of preceding line comments. This is important to our goal of being able to programmatically modify the  futhark.pkg$ file while keeping comments intact.futharkA line comment.futharkThe dependencies of a (revision of a) package is a mapping from package paths to minimum versions (and an optional hash pinning).futharkA package path is a unique identifier for a package, for example  github.comuserfoo.futharkTurn a package path (which always uses forward slashes) into a file path in the local file system (which might use different slashes).futharkVersions of the form (0,0,0)-timestamp+hash are treated specially, as a reference to the commit identified uniquely with hash (typically the Git commit ID). This function detects such versions.futharkcommitVersion timestamp commit constructs a commit version.futharkUnfortunately, Data.Versions has a buggy semver parser that collapses consecutive zeroes in the metadata field. So, we define our own parser here. It's a little simpler too, since we don't need full semver.futhark9The name of the file containing the futhark-pkg manifest.futharkPossibly given a package path, construct an otherwise-empty manifest file.futharkPrettyprint a package manifest such that it can be written to a  futhark.pkg file.futhark3The required packages listed in a package manifest.futharkWhere in the corresponding repository archive we can expect to find the package files.futharkAdd new required package to the package manifest. If the package was already present, return the old version.futhark6Remove a required package from the manifest. Returns . if the package was not found in the manifest, and otherwise the new manifest and the  that was present.futharkParse a text as a . The . is used for any error messages.futhark%Read contents of file and pass it to .futharkPrettyprint a build list; one package per line and newline-terminated./qz{|}~/z{|}~q Trustworthy2*futhark Encoded form.futharkAs the user typed it.futharkLike nub$, but without the quadratic runtime.futharkLike nubBy$, but without the quadratic runtime.futharkLike , but monadic.futhark chunk n a splits a into n!-size-chunks. If the length of a is not divisible by n', the last chunk will have fewer than n' elements (but it will never be empty).futhark chunks ns a splits a, into chunks determined by the elements of ns. It must hold that sum ns == length a, or the resulting list may contain too few chunks, or not all elements of a.futharkLike .%, but returns zero for an empty list.futhark dropAt i n drops n elements starting at element i.futhark takeLast n l takes the last n elements of l.futhark dropLast n l drops the last n elements of l.futharkA combination of . and ..futharkReturn the list element at the given index, if the index is valid.futhark3Return the first element of the list, if it exists.futharkLike ., but from the end.futharkLike ., but produces three lists.futharkReturn the list element at the given index, if the index is valid, along with the elements before and after.futharkCompute a hash of a text that is stable across OS versions. Returns the hash as a text as well, ready for human consumption.futhark7The Unix environment when the Futhark compiler started.futharkTrue if the environment variable, viewed as an integer, has at least this numeric value. Returns False if variable is unset or not numeric.futharkAre we running in a terminal capable of fancy commands and visualisation?futharkLike ., but also wraps exceptions when the indicated binary cannot be launched, or some other exception is thrown. Also does shenanigans to handle improperly encoded outputs.futhark7Every non-directory file contained in a directory tree.futhark9Round a single-precision floating point number correctly.futharkRound a single-precision floating point number upwards correctly.futharkRound a single-precision floating point number downwards correctly.futhark9Round a double-precision floating point number correctly.futharkRound a double-precision floating point number upwards correctly.futharkRound a double-precision floating point number downwards correctly.futharkThe system-level lgamma() function.futharkThe system-level  lgammaf() function.futharkThe system-level tgamma() function.futharkThe system-level  tgammaf() function.futharkThe system-level hypot function.futharkThe system-level hypotf function.futhark?ufuthark*Typeclass for monads that support logging.futharkAdd one log entry.futharkAppend an entire log.futharkTypeclass for things that can be turned into a single-entry log.futhark1An efficiently catenable sequence of log entries.futharkTransform a log into text. Every log entry becomes its own line (or possibly more, in case of multi-line entries).None futharkMonads that support a stateful package registry. These are also required to be instances of . because most package registry operations involve network operations.futharkA package registry is a mapping from package paths to information about the package. It is unlikely that any given registry is global; rather small registries are constructed on-demand based on the package paths referenced by the user, and may also be combined monoidically. In essence, the PkgRegistry is just a cache.futharkInformation about a package. The name of the package is stored separately.futharkLook up information about a specific commit, or HEAD in case of Nothing.futharkInformation about a version of a single package. The version number is stored separately.futhark1The directory inside the zipball containing the lib directory, in which the package files themselves are stored (Based on the package path).futharkThe commit ID can be used for verification ("freezing"), by storing what it was at the time this version was last selected.futhark8Timestamp for when the revision was made (rarely used).futharkThe manifest is stored as a monadic action, because we want to fetch them on-demand. It would be a waste to fetch it information for every version of every package if we only actually need a small subset of them.futharkDownload the zip archive corresponding to a specific package version.futhark6Lookup information about a given version of a package.futharkRetrieve information about a package based on its package path. This uses Semantic Import Versioning when interacting with repositories. For example, a package  github.comuserrepo6 will match version 0.* or 1.* tags only, a package  github.comuserrepo/v2$ will match 2.* tags, and so forth..futhark=Given a package path, look up information about that package.futhark:Look up information about a specific version of a package.futhark%Find the newest version of a package.None ?PfutharkA mapping of package revisions to the dependencies of that package. Can be considered a  without the option of obtaining more information from the Internet. Probably useful only for testing the solver.futharkRun the solver, producing both a package registry containing a cache of the lookups performed, as well as a build list.futharkPerform package resolution with only pre-known information. This is useful for testing. Safe-Inferred`futhark.Prettyprint a value, wrapped to 80 characters.futharkPrettyprint a value to a ., wrapped to 80 characters.futharkPrettyprint a value to a . without any width restriction.futhark2Prettyprint a value without any width restriction.futhark Re-export of ..futhark,Prettyprint a list enclosed in curly braces.futharkLike *, but put a linebreak after every element.futhark The document  ds separates ds1 with commas and encloses them with parentheses.futharkMake sure that the given document is printed on just a single line.futharkLike g, but splits the string into words and permits line breaks between all of them.futharkStack and prepend a list of h s to another h?, separated by a linebreak. If the list is empty, the second h1 will be returned without a preceding linebreak.futharkSurround the given document with enclosers and add linebreaks and indents.futharkPrettyprint on a single line up to at most some appropriate number of characters, with trailing ... if necessary. Used for error messages.futharkLike .", but a newline after every comma...... !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghpijklmon !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghpijklmon Trustworthy>ýfutharkLike a  , but also grouped in compound ways that are not supported by raw values. You cannot parse or read these in standard ways, and they cannot be elements of arrays.futharkThe structure of a compound value, parameterised over the actual values. For most cases you probably want .futharkMust not be single value.futhark4Create a tuple for a non-unit list, and otherwise a futharkIf the value is a tuple, extract the components, otherwise return a singleton list of the value.9.. .......... . ................/////////////////None ?͋futhark#How to evaluate a builtin function.futharkThe intermediate values produced by an expression - in particular, these may not be on the server.futhark2A Haskell-level value or a variable on the server.futharkThe type of a * - either a value type or a function type.futharkIns, then outs.futharkA ScriptValue is either a base value or a partially applied function. We don't have real first-class functions in FutharkScript, but we sort of have closures.futharkIns, then outs. Yes, this is the opposite of more or less everywhere else.futharkA FutharkScript expression. This is a simple AST that might not correspond exactly to what the user wrote (e.g. no parentheses or source locations). This is fine for small expressions, which is all this is meant for.futharkServer-side variable, *not* Futhark variable (these are handled in ).futharkA function called in a  expression can be either a Futhark function or a builtin function.futharkLike a /, but keeps a bit more state to make FutharkScript more convenient.futharkRun an action with a  produced by an existing /&, without shutting it down at the end.futharkStart a server, execute an action, then shut down the server. Similar to /.futharkUnsigned integer division. Rounds towards positive infinity.futharkSigned integer division. Rounds towards negativity infinity. Note: this is different from LLVM.futhark?5B7futharkEvery statement is associated with a set of attributes, which can have various effects throughout the compiler.futharkA single attribute.futharkA part of an error message.futharkA literal string.futharkA run-time value.futharkAn error message is a list of error parts, which are concatenated to form the final message.futharkAn element of a pattern - consisting of a name and an addditional parametric decoration. This decoration is what is expected to contain the type of the resulting variable.futharkThe name being bound.futharkPat element decoration.futhark A list of s, indicating how an array should be sliced. Whenever a function accepts a , that slice should be total, i.e, cover all dimensions of the array. Deviators should be indicated by taking a list of  es instead.futhark,How to index a single dimension of an array.futharkFix index in this dimension.futhark&DimSlice start_offset num_elems stride.futharkA function or lambda parameter.futharkAttributes of the parameter. When constructing a parameter, feel free to just pass /.futharkName of the parameter.futharkFunction parameter decoration.futharkA subexpression is either a scalar constant or a variable. One important property is that evaluation of a subexpression is guaranteed to complete in constant time.futhark:A list of names used for certificates in some expressions.futharkAn identifier consists of its name and the type of the value bound to the identifier.futharkInformation about which parts of a value/type are consumed. For example, we might say that a function taking three arguments of types ([int], *[int], [int]) has diet [Observe, Consume, Observe].futharkConsumes this value.futharkOnly observes value in this position, does not consume. A result may alias this.futharkAs , but the result will not alias, because the parameter does not carry aliases.futharkAn > with uniqueness information, used for function return types.futharkA type with shape and uniqueness information, used declaring return- and parameters types.futharkA type with existentially quantified shapes - used as part of function (and function-like) return types. Generally only makes sense when used in a list.futharkA type with shape information, used for describing the type of variables.futhark>The type of a value. When comparing types for equality with /, shapes must match.futhark1Token, index space, element type, and uniqueness.futharkA fancier name for ()% - encodes no uniqueness information.futhark:A string representing a specific non-default memory space.futhark!The memory space of a block. If , this is the "default" space, whatever that is. The exact meaning of the  depends on the backend used. In GPU kernels, for example, this is used to distinguish between constant, global and shared memory spaces. In GPU-enabled host code, it is used to distinguish between host memory () and GPU space.futharkA special kind of memory that is a statically sized array of some primitive type. Used for private memory on GPUs.futhark>A class encompassing types containing array shape information.futhark0Return the rank of an array with the given size.futharkstripDims n shape strips the outer n dimensions from shape.futhark5Check whether one shape if a subset of another shape.futharkThe size of an array type as merely the number of dimensions, with no further information.futharkLike  but some of its elements may be bound in a local environment instead. These are denoted with integral indices.futharkThe size of this dimension.futhark"Something that may be existential.futharkThe size of an array as a list of subexpressions. If a variable, that variable must be in scope where this array is used.futharkThe size of an array type as a list of its dimension sizes, with the type of sizes being parametric.futhark2Whether some operator is commutative or not. The /: instance returns the least commutative of its arguments.futharkIf the argument is a , return its component.futharkIf the slice is all s, return the components.futhark3The dimensions of the array produced by this slice.futharkA slice with a stride of one.futharkFix the ?s of a slice. The number of indexes must equal the length of  for the slice.futharkFurther slice the >s of a slice. The number of slices must equal the length of  for the slice.futharkHow many non-constant parts does the error message have, and what is their type?futhark Construct  from a single .futhark8Is the given attribute to be found in the attribute set?futharkx  y gives x# except for any attributes also in y.futharkNumber of elements in dimensionfutharkStride of dimension svwy xNone:<futhark$If a Haskell type is an instance of , it means that a value of that type can be converted to a Futhark . This is intended to cut down on boilerplate when writing compiler code - for example, you'll quickly grow tired of writing Constant (LogVal True) loc.futhark Create a   containing the given value.futhark1Utility definition for reasons of type ambiguity.futhark1Utility definition for reasons of type ambiguity.None>?R9futharkSomething with an existential context that can be (partially) fixed.futharkFix the given existentional variable to the indicated free value.futhark/Typeclass for things whose type can be changed.futhark"Typeclass for things that contain s.futhark"Typeclass for things that contain s.futhark"Typeclass for things that contain s.futhark"Typeclass for things that contain s.futhark%Remove shape information from a type.futharkReturn the dimensionality of a type. For non-arrays, this is zero. For a one-dimensional array it is one, for a two-dimensional it is two, and so forth.futhark:Return the shape of a type - for non-arrays, this is the /.futharkSet the shape of an array. If the given type is not an array, return the type unchanged.futharkTrue if the given type has a dimension that is existentially sized.futhark Return the uniqueness of a type.futharkunique t is /' if the type of the argument is unique.futharkConvert types with non-existential shapes to types with non-existential shapes. Only the representation is changed, so all the shapes will be .futharkAs , but on a single type.futhark arrayOf t s u constructs an array type. The convenience compared to using the  constructor directly is that t can itself be an array. If t is an n-dimensional array, and s is a list of length n, the resulting type is of an n+m6 dimensions. The uniqueness of the new array will be u, no matter the uniqueness of t. If the shape s has rank 0, then the t will be returned, although if it is an array, with the uniqueness changed to u.futharkConstruct an array whose rows are the given type, and the outer size is the given dimension. This is just a convenient wrapper around .futharkConstruct an array whose rows are the given type, and the outer size is the given -. This is just a convenient wrapper around .futharkSet the dimensions of an array. If the given type is not an array, return the type unchanged.futharkReplace the size of the outermost dimension of an array. If the given type is not an array, it is returned unchanged.futharkReplace the size of the given dimension of an array. If the given type is not an array, it is returned unchanged.futhark2Replace the outermost dimension of an array shape.futhark2Replace the specified dimension of an array shape.futhark peelArray n t4 returns the type resulting from peeling the first n array dimensions from t . Returns Nothing if t has less than n dimensions.futharkstripArray n t removes the n outermost layers of the array. Essentially, it is the type of indexing an array of type t with n indexes.futharkReturn the size of the given dimension. If the dimension does not exist, the zero constant is returned.futharkReturn the dimensions of a type - for non-arrays, this is the empty list.futharkReturn the existential dimensions of a type - for non-arrays, this is the empty list.futharkReturn the size of the given dimension. If the dimension does not exist, the zero constant is returned.futharkReturn the size of the given dimension in the first element of the given type list. If the dimension does not exist, or no types are given, the zero constant is returned.futhark0Return the immediate row-type of an array. For [[int]], this would be [int].futharkA type is a primitive type if it is not an array or memory block.futhark.Returns the bottommost type of an array. For [][]i32, this would be i325. If the given type is not an array, it is returned.futhark*Swap the two outer dimensions of the type.futharkRearrange the dimensions of the type. If the length of the permutation does not match the rank of the type, the permutation will be extended with identity.futharkTransform any s in the type.futharkTransform any s in the type.futharkdiet t< returns a description of how a function parameter of type t might consume its argument.futharkx `subtypeOf` y is true if x is a subtype of y (or equal to y ), meaning x is valid whenever y is.futharkxs `subtypesOf` ys is true if xs is the same size as ys, and each element in xs/ is a subtype of the corresponding element in ys..futhark2Add the given uniqueness information to the types. futhark,Remove uniqueness information from the type. futhark5If an existential, then return its existential index. futhark'If a known size, then return that size. futharkGiven the existential return type of a function, and the shapes of the values returned by the function, return the existential shape context. That is, those sizes that are existential in the return type. futharkThe 8 integers used for existential sizes in the given types. futharkIf all dimensions of the given 4 are statically known, change to the corresponding . futharkGiven two lists of (s of the same length, return a list of (s that is a subtype of the two operands. futharkGiven a list of s and a list of "forbidden" names, modify the dimensions of the s such that they are  where they were previously 0 with a variable in the set of forbidden names. futhark-Produce a mapping for the dimensions context. futhark  IntType Int8 futhark  IntType Int16 futhark  IntType Int32 futhark  IntType Int64 futhark FloatType Float32 futhark FloatType Float64> > None>Vz futharkA type representing the return type of a function. In practice, a list of these will be used. It should contain at least the information contained in an 5, but may have more, notably an existential context. futhark-Contruct a return type from a primitive type. futharkGiven a function return type, the parameters of the function, and the arguments for a concrete call, return the instantiated return type for the concrete call, if valid. futharkA type representing the return type of a body. It should contain at least the information contained in a list of 6s, but may have more, notably an existential context. futhark,Construct a body type from a primitive type. futharkGiven shape parameter names and types, produce the types of arguments accepted.  None?Y& futharkA collection of type families giving various common types for a representation, along with constraints specifying that the types they map to should satisfy some minimal requirements. futhark)Decoration for every let-pattern element. futhark Decoration for every expression. futharkDecoration for every body. futhark5Decoration for every (non-lambda) function parameter. futhark/Decoration for every lambda function parameter. futhark-The return type decoration of function calls. futhark'The return type decoration of branches. futharkExtensible operation. ! Trustworthy 2>?uH futharkAn entire Futhark program. futharkTop-level constants that are computed at program startup, and which are in scope inside all functions. futharkThe functions comprising the program. All funtions are also available in scope in the definitions of the constants, so be careful not to introduce circular dependencies (not currently checked). futharkInformation about the inputs and outputs (return value) of an entry point. futharkAn entry point parameter, comprising its name and original type. futharkEvery entry point argument and return value has an annotation indicating how it maps to the original source program type. futhark6Is an unsigned integer or array of unsigned integers. futharkA black box type comprising this many core values. The string is a human-readable description with no other semantics. futharkMaps directly. futharkFunction Declarations futhark5Contains a value if this function is an entry point. futharkA lambda parameter. futharkA function and loop parameter. futhark#Type alias for namespacing reasons. futhark%Anonymous function for use in a SOAC. futhark#A type alias for namespace control. futharkWhat kind of branch is this? This has no semantic meaning, but provides hints to simplifications. futharkAn ordinary branch. futharkA branch where the "true" case is what we are actually interested in, and the "false" case is only present as a fallback for when the true case cannot be safely evaluated. The compiler is permitted to optimise away the branch if the true case contains only safe statements. futharkBoth of these branches are semantically equivalent, and it is fine to eliminate one if it turns out to have problems (e.g. contain things we cannot generate code for). futharkData associated with a branch. futharkFor-loop or while-loop? futhark'The root Futhark expression type. The   constructor contains a rep-specific operation. Do-loops, branches and function calls are special. Everything else is a simple  . futhark#A simple (non-recursive) operation. futhark'loop {a} = {v} (for i < n|while b) do b. futharkCreate accumulators backed by the given arrays (which are consumed) and pass them to the lambda, which must return the updated accumulators and possibly some extra values. The accumulators are turned back into arrays. The  is the write index space. The corresponding arrays must all have this shape outermost. This construct is not part of   because we need the rep parameter. futharkThe input to a   construct. Comprises the index space of the accumulator, the underlying arrays, and possibly a combining function. futharkA primitive operation that returns something of known size and does not itself contain any bindings. futharkA variable or constant. futharkSemantically and operationally just identity, but is invisible/impenetrable to optimisations (hopefully). This partially a hack to avoid optimisation (so, to work around compiler limitations), but is also used to implement tracing and other operations that are semantically invisible, but have some sort of effect (brrr). futharkArray literals, e.g., [ [1+x, 3], [2, 1+4] ];. Second arg is the element type of the rows of the array. futharkUnary operation. futharkBinary operation. futhark+Comparison - result type is always boolean. futharkConversion "casting". futharkTurn a boolean into a certificate, halting the program with the given error message if the boolean is false. futhark5The certificates for bounds-checking are part of the  . futharkAn in-place update of the given array at the given position. Consumes the array. If , perform a run-time bounds check and ignore the write if out of bounds (like Scatter). futharkconcat!0([1],[2, 3, 4]) = [1, 2, 3, 4]@. futhark:Copy the given array. The result will not alias anything. futharkManifest an array with dimensions represented in the given order. The result will not alias anything. futhark$iota(n, x, s) = [x,x+s,..,x+(n-1)*s].The  indicates the type of the array returned and the offset/stride arguments, but not the length argument. futhark +replicate([3][2],1) = [[1,1], [1,1], [1,1]] futhark>Create array of given type and shape, with undefined elements. futhark71st arg is the new shape, 2nd arg is the input array *) futharkPermute the dimensions of the input array. The list of integers is a list of dimensions (0-indexed), which must be a permutation of [0,n-1], where n1 is the number of dimensions in the input array. futharkRotate the dimensions of the input array. The list of subexpressions specify how much each dimension is rotated. The length of this list must be equal to the rank of the array. futharkUpdate an accumulator at the given index with the given value. Consumes the accumulator and produces a new one. futhark4Apart from being Opaque, what else is going on here? futharkNo special operation. futhark,Print the argument, prefixed by this string. futhark A list of  -s, indicating the new dimensions of an array. futharkThe new dimension in a  -like operation. This allows us to disambiguate "real" reshapes, that change the actual shape of the array, from type coercions that are just present to make the types work out. The two constructors are considered equal for purposes of /. futharkThe new dimension is guaranteed to be numerically equal to the old one. futharkThe new dimension is not necessarily numerically equal to the old one. futhark!Type alias for namespace reasons. futharkA body consists of a number of bindings, terminating in a result (essentially a tuple literal). futhark5The result of a body is a sequence of subexpressions. futhark3A pairing of a subexpression and some certificates. futharkA sequence of statements. futharkA local variable binding. futharkPat. futhark Auxiliary information statement. futhark Expression. futhark3Auxilliary Information associated with a statement. futhark#A type alias for namespace control. futhark?A pattern is conceptually just a list of names and their types. futhark#A type alias for namespace control. futharkA single statement. futhark1Convert a statement list to a statement sequence. futhark1Convert a statement sequence to a statement list. futhark,The first statement in the sequence, if any. futhark Construct a   with no certificates. futhark Construct a   from a variable name. futhark Construct a   from subexpressions. futhark Construct a   from variable names. svwy x      " Safe-Inferred futharkThe new dimension. futhark6The new dimensions resulting from a reshape operation. futhark1The new shape resulting from a reshape operation. futhark Construct a  " where all dimension changes are  s. futhark reshapeOuter newshape n oldshape returns a  % expression that replaces the outer n dimensions of oldshape with newshape. futhark reshapeInner newshape n oldshape returns a  % expression that replaces the inner m-n dimensions (where m is the rank of oldshape) of src with newshape. futharkIf the shape change is nothing but shape coercions, return the new dimensions. Otherwise, return .. futharkfuseReshape s1 s2 creates a new  2 that is semantically the same as first applying s1 and then s2-. This may take advantage of properties of   versus   to preserve information. futharkGiven concrete information about the shape of the source array, convert some  s into  s. futhark!reshapeIndex to_dims from_dims is transforms the index list is" (which is into an array of shape  from_dims) into an index list is'", which is into an array of shape to_dims. is must have the same length as  from_dims, and is' will have the same length as to_dims. futharkunflattenIndex dims i: computes a list of indices into an array with dimension dims given the flat index i2. The resulting list will have the same size as dims. futharkflattenIndex dims is computes the flat index of is into an array with dimensions dims. The length of dims and is must be the same. futharkGiven a length n list of dimensions dims, sizeSizes dims will compute a length n+1 list of the size of each possible array slice. The first element of this list will be the product of dims!, and the last element will be 1. #None?Z futharkThe  of a parameter. futharkThe  of a parameter. futharkAn  corresponding to a parameter. futharkAn $ corresponding to a pattern element. futharkThe type of a name bound by a  . futharkSet the rep of a  . futharkReturn a list of the s bound by the  . futharkReturn a list of the s bound by the  . futhark1Return a list of the typess bound by the pattern. futhark0Return the number of names bound by the pattern. futharkCreate a pattern using  as the attribute. $ Safe-Inferred >?; futharkThe class of representations whose annotations can be prettyprinted. futharkLike , but produces a h.  % Trustworthy-2>? futhark4A monad transformer that carries around an extended  . Its  ( method will first look in the extended  , and then use the   method of the underlying monad. futhark>A constraint that indicates two representations have the same   representation. futharkThe class of things that can provide a scope. There is no overarching rule for what this means. For a  +, it is the corresponding pattern. For a  , is is the parameters. futhark,The class of monads that not only provide a  1, but also the ability to locally extend it. A / containing a  - is the prototypical example of such a monad. futharkRun a computation with an extended type environment. Note that this is intended to *add* to the current type environment, it does not replace it. futharkThe class of applicative functors (or more common in practice: monads) that permit the lookup of variable types. A default method for   exists, which is sufficient (if not always maximally efficient, and using / to fail) when   is defined. futharkReturn the type of the given variable, or fail if it is not in the type environment. futharkReturn the info of the given variable, or fail if it is not in the type environment. futharkReturn the type environment contained in the applicative functor. futharkReturn the result of applying some function to the type environment. futharkA scope is a mapping from variable names to information about that name. futhark!How some name in scope was bound. futhark"Extend the monadic scope with the   the given value. futharkThe scope of a pattern. futharkThe scope of a pattern element. futhark$The scope of some lambda parameters. futhark.The scope of some function or loop parameters. futharkIf two scopes are really the same, then you can convert one to the other. futhark3Run a computation in the extended type environment.  &None futharkThis representatin supports an   for its  .. This is used for some simplification rules. futharkTransform every sub-  of this op. futharkA function for monadically traversing any sub-statements of the given op for some representation. futharkExpress a monad expression on a syntax node. Each element of this structure expresses the action to be performed on a given child. futharkExpress a monad mapping operation on a syntax node. Each element of this structure expresses the operation to be performed on a given child. futharkMost bodies are enclosed in a scope, which is passed along for convenience. futhark/A mapper that simply returns the tree verbatim. futharkMap a monadic action across the immediate children of an expression. Importantly, the mapping does not descend recursively into subexpressions. The mapping is done left-to-right. futharkLike   , but in the / monad. futharkA no-op traversal. futharkAs  $, but do not construct a result AST. futharkA helper for defining  .  'None >? futharkAny operation must define an instance of this class, which describes the type of the operation (at the value level). futharkThe type of a subexpression. futharkType type of a   - not that this might refer to names bound in the body containing the result. futharkmapType f arrts* wraps each element in the return type of f in an array with size equal to the outermost dimension of the first element of arrts. futhark"The type of a primitive operation. futharkThe type of an expression. futhark/The number of values returned by an expression.&  (None>?w futharkEither return precomputed free names stored in the attribute, or the freshly computed names. Relies on lazy evaluation to avoid the work. futharkA class indicating that we can obtain free variable information from values of this type. futhark+A computation to build a free variable set. futharkA set of names. Note that the /0 instance is a dummy that treats everything as / if /, and otherwise /. futharkRetrieve the data structure underlying the names representation. futhark(Does the set of names contain this name? futhark(Construct a name set from a list. Slow. futhark,Turn a name set into a list of names. Slow. futhark(Construct a name set from a single name. futhark"The intersection of two name sets. futharkDo the two name sets intersect? futhark-Subtract the latter name set from the former. futharkMap over the names in a set. futhark-Consider a variable to be bound in the given   computation. futhark"Take note of a variable reference. futhark*Take note of a set of variable references. futharkReturn the set of variable names that are free in the given statements and result. Filters away the names that are bound by the statements. futhark/The free variables of some syntactic construct. futhark1The names bound by the bindings immediately in a  . futharkThe names bound by a binding. futhark The names bound by the bindings. futhark:1 futharkThe class of floating-point types that can be used for constructing  s. futhark-Construct a typed expression from a rational. futhark>The class of integer types that can be used for constructing  s. futhark>The class of numeric types that can be used for constructing  s. futhark-Construct a typed expression from an integer. futharkConstruct a numeric expression from a boolean expression. This can be used to encode arithmetic control flow. futharkA   tagged with a phantom type used to provide type-safe construction. Does not guarantee that the underlying expression is actually type correct. futharkA primitive expression parametrised over the representation of free variables. Note that the /, /, and /< instances perform automatic (but simple) constant folding.Note also that the / instance assumes  semantics! futharkThis expression is of type . futharkThis expression is of type . futharkThis expression is of type . futharkThis expression is of type . futharkThis is a boolean expression. futharkThis expression is of type  . futharkThis expression is of type /. futharkThis expression is of type /. futhark True if the   has at least this many nodes. This can be much more efficient than comparing with / for large  s, as this function is lazy. futharkPerform quick and dirty constant folding on the top level of a PrimExp. This is necessary because we want to consider e.g. equality modulo constant folding. futharkLifted logical conjunction. futharkLifted logical conjunction. futharkLifted relational operators; assuming signed numbers in case of integers. futharkLifted relational operators; assuming signed numbers in case of integers. futharkLifted relational operators; assuming signed numbers in case of integers. futharkLifted relational operators; assuming signed numbers in case of integers. futharkLifted relational operators; assuming signed numbers in case of integers. futharkLifted bitwise operators. The right-shift is logical, *not* arithmetic. futharkLifted bitwise operators. The right-shift is logical, *not* arithmetic. futharkLifted bitwise operators. The right-shift is logical, *not* arithmetic. futharkLifted bitwise operators. The right-shift is logical, *not* arithmetic. futharkLifted bitwise operators. The right-shift is logical, *not* arithmetic. futharkUntyped smart constructor for sign extension that does a bit of constant folding. futharkUntyped smart constructor for zero extension that does a bit of constant folding. futhark Evaluate a   in the given monad. Invokes / on type errors. futhark!The type of values returned by a  4. This function returning does not imply that the   is type-correct. futhark If the given   is a constant of the wrong integer type, coerce it to the given integer type. This is a workaround for an issue in the / instance. futharkBoolean-valued PrimExps. futharkBoolean-valued PrimExps. futhark#Boolean negation smart constructor. futharkSMax on 32-bit integers. futharkSMin on 32-bit integers. futharkSMax on 64-bit integers. futharkSMin on 64-bit integers. futharkSign-extend to 32 bit integer. futharkSign-extend to 64 bit integer. futharkZero-extend to 32 bit integer. futharkZero-extend to 64 bit integer. futhark64-bit float minimum. futhark64-bit float maximum. futhark)Produce a mapping from the leaves of the   to their designated types.  :  3 2 4 4 4 4 4*None->? futharkRepresentations in which all annotations support name substitution. futharkA type that is an instance of this class supports substitution of any names contained within. futharksubstituteNames m e replaces the variable names in e* with new names, based on the mapping in m$. It is assumed that all names in e( are unique, i.e. there is no shadowing. futharkThe substitutions to be made are given by a mapping from names to names.  +None futhark8A heuristic for setting the default value for something. futhark&A size that can be assigned a default. futharkThe value supplies by a heuristic can depend on some device information. This will be translated into a call to clGetDeviceInfo(). Make sure to only request info that can be casted to a scalar type. futhark9The type of OpenCL device that this heuristic applies to. futharkAll of our heuristics.  ,None ; futharkParse a   given a leaf parser.   -NoneQ futharkGeneralize two  s of the the same type.  . Trustworthy  futhark#Phantom type for number of threads. futhark/Phantom type for the group size of some kernel. futhark5Phantom type for the number of groups of some kernel. futharkA wrapper supporting a phantom type for indicating what we are counting. futharkThe class of some kind of configurable size. Each class may impose constraints on the valid values. futhark%A threshold with an optional default. futharkLikely not useful on its own, but querying the maximum can be handy. futharkA bespoke size with a default. futharkAn indication of which comparisons have been performed to get to this point, as well as the result of each comparison. futhark$The default value for the size. If .(, that means the backend gets to decide.  / Safe-Inferred;  futharkA name source is conceptually an infinite sequence of names with no repeating entries. In practice, when asked for a name, the name source will return the name along with a new name source, which should then be used in place of the original.The / instance is based on how many names have been extracted from the name source. futhark9Produce a fresh name, using the given name as a template. futharkA blank name source. futhark=A new name source that starts counting from the given number.  0 Safe-Inferred>futharkA monad that stores a name source. The following is a good instance for a monad in which the only state is a  NameSource vn:  instance MonadFreshNames vn MyMonad where getNameSource = get putNameSource = put futharkRun a computation needing a fresh name source and returning a new one, using  and # before and after the computation.futhark9Produce a fresh name, using the given name as a template.futharkAs newName, but takes a . for the name template.futharkProduce a fresh *, using the given base name as a template.futharkProduce a fresh %, using the given name as a template.futharkProduce a fresh , using the given 1 as a template, but possibly modifying the name.futharkProduce a fresh %, using the given name as a template.   1 Trustworthy->?futhark8Representations in which all decorations are renameable.futharkMembers of class  can be uniquely renamed.futharkRename the given value such that it does not contain shadowing, and has incorporated any substitutions present in the  environment.futhark)The monad in which renaming is performed.futharkRename variables such that each is unique. The semantics of the program are unaffected, under the assumption that the program was correct to begin with. In particular, the renaming may make an invalid program valid.futharkRename bound variables such that each is unique. The semantics of the expression is unaffected, under the assumption that the expression was correct to begin with. Any free variables are left untouched.futharkRename bound variables such that each is unique. The semantics of the binding is unaffected, under the assumption that the binding was correct to begin with. Any free variables are left untouched, as are the names in the pattern of the binding.futharkRename bound variables such that each is unique. The semantics of the body is unaffected, under the assumption that the body was correct to begin with. Any free variables are left untouched.futharkRename bound variables such that each is unique. The semantics of the lambda is unaffected, under the assumption that the body was correct to begin with. Any free variables are left untouched. Note in particular that the parameters of the lambda are renamed.futharkProduce an equivalent pattern but with each pattern element given a new name.futharkRename the bound variables in something (does not affect free variables).futharkPerform a renaming using the   instance. This only works if the argument does not itself perform any name binding, but it can save on boilerplate for simple types.futharkRename variables in binding position. The provided VNames are associated with new, fresh names in the renaming environment.futharkRename some statements, then execute an action with the name substitutions induced by the statements active.2None  ->?futharkRepresentation-specific attributes; also means the rep supports some basic facilities.futharkGiven a pattern, construct the type of a body that would match it. An implementation for many representations would be .futharkA type class for operations.futharkLike , but for arbitrary ops.futhark,Should we try to hoist this out of branches?futharkA handy shorthand for properties that we usually want to things we stuff into ASTs.futharkisBuiltInFunction k is / if k is an element of .futhark0A map of all built-in functions and their types.futharkIf the expression is a  , return it, otherwise ..futharkAn expression is safe if it is always well-defined (assuming that any required certificates have been checked) in any context. For example, array indexing is not safe, as the index may be out of bounds. On the other hand, adding two numbers cannot fail.futhark"Return the variable names used in * subexpressions. May contain duplicates.futharkIf the  is a  return the variable name.futharkDoes the given lambda represent a known commutative function? Based on pattern matching and checking whether the lambda represents a known arithmetic operator; don't expect anything clever here.futharkHow many value parameters are accepted by this entry point? This is used to determine which of the function parameters correspond to the parameters of the original function (they must all come at the end).futharkA   with empty .futhark-The certificates associated with a statement.futhark Add certificates to a statement.futharkConstruct the type of an expression that would match the pattern.futhark1Keep only those attributes that are relevant for   expressions.futhark?ofutharkThe class of operations that can be given aliasing information. This is a somewhat subtle concept that is only used in the simplifier and when using "rep adapters".futhark3The op that results when we add aliases to this op.futharkRemove aliases from this op.futharkAdd aliases to this op.futharkPre-existing aliases for variables. Used to add transitive aliases.futharkThe class of operations that can produce aliasing and consumption information.futhark*Something that contains alias information.futhark"The alias of the argument element.futhark?The class of representations that contain aliasing information.futhark The aliases of the body results.futhark#The variables consumed in the body.futharkThe alises of a subexpression.futharkThe aliases of an expression, one per non-context value returned.futhark)The variables consumed in this statement.futhark*The variables consumed in this expression.futhark&The variables consumed by this lambda.futhark? futhark$The most commonly used binder monad.futhark;A monad transformer that tracks statements and provides a  instance, assuming that the underlying monad provides a name source. In almost all cases, this is what you will use for constructing statements (possibly as part of a larger monad stack). If you find yourself needing to implement  from scratch, then it is likely that you are making a mistake.futharkA  (and by extension, a ) is only an instance of  for representations that implement this type class, which contains methods for constructing statements.futharkRun a binder action given an initial scope, returning a value and the statements added () during the action.futharkLike !, but return only the statements.futharkLike 4, but get the initial scope from the current monad.futharkLike 4, but get the initial scope from the current monad.futharkRun a binder action, returning a value and the statements added () during the action. Assumes that the current monad provides initial scope and name source.futharkLike , but throw away the result and just return the added statements.futharkRun a binder that produces a  , and prefix that  < by the statements produced during execution of the action.3  ;None  >??futhark'The aliases of what is returned by the  %, and what is consumed inside of it.futhark&Everything consumed in the expression.futhark&The aliases of the let-bound variable.futharkA wrapper around ) to get around the fact that we need an /) instance, which 'AliasDec does not have.futhark%The rep for the basic representation.futharkThe aliases of the result and everything consumed in the given statements. svwy x <None ->?futhark:Constraints that let us transform a representation into a  representation.futharkWisdom about an expression.futhark%The wisdom of the let-bound variable.=None? Afuthark,Perform alias analysis on a Futhark program.>None>?futharkInstances of this class can be converted to Futhark expressions within a .futharkAs  , but an   can be given.futhark Construct an  3 expressions that slices an array with unit stride.futhark.Are these indexes out-of-bounds for the array?futhark1Construct an unspecified value of the given type.futhark&Sign-extend to the given integer type.futhark&Zero-extend to the given integer type.futharkApply a binary operator to several subexpressions. A left-fold.futharkTrue if all operands are true.futharkCreate a two-parameter lambda whose body applies the given binary operation to its arguments. It is assumed that both argument and result types are the same. (This assumption should be fixed at some point.)futharkAs  , but for s.futharkEasily construct a   within a .futhark)Slice a full dimension of the given size.futharkfullSlice t slice returns slice , but with ?s of entire dimensions appended to the full dimensionality of t. This function is used to turn incomplete indexing complete, as required by  .futhark sliceAt t n slice returns slice but with s of the outer n dimensions prepended, and as many appended as to make it a full slice. This is a generalisation of .futharkLike (, but the dimensions are simply numeric.futharkDoes the slice describe the full size of the array? The most obvious such slice is one that s the full span of every dimension, but also one that fixes all unit dimensions.futhark8Conveniently construct a body that contains no bindings.futharkConveniently construct a body that contains no bindings - but this time, monadically!futharkEvaluate the action, producing a body, then wrap it in all the bindings it created using .futhark#Evaluate an action that produces a   and an auxiliary value, then return the body constructed from the   and any statements added during the action, along the auxiliary value.futharkAs ", but there is no auxiliary value.futharkChange that result where evaluation of the body would stop. Also change type annotations at branches.futharkInstantiate all existential parts dimensions of the given type, using a monadic action to create the necessary s. You should call this function within some monad that allows you to collect the actions performed (say, Writer).futhark!Can be used as the definition of  for a & instance for simple representations.futharkA convenient composition of  and . /? Trustworthy 9>? futhark6The class of representations that can be type-checked.futhark/Used at top level; can be locally changed with .futhark$The type checker runs in this monad.futhark A type error.futhark6Information about an error during type checking. The /? instance for this type produces a human-readable description.futharkAdd information about what is being type-checked to the current context. Liberal use of this combinator makes it easier to track type errors, as the strings are added to type errors signalled via .futhark5Proclaim that we have written to the given variables.futharkPermit consumption of only the specified names. If one of these names is consumed, the consumption will be rewritten to be a consumption of the corresponding alias set. Consumption of anything else will result in a type error.futhark require ts se* causes a '(TypeError vn)' if the type of se* is not a subtype of one of the types in ts.futhark Variant of  working on variable names.futharkType check a program containing arbitrary type information, yielding either a type error or a program with complete type information.futharkRemove all aliases from the /.@ Trustworthy ? futharkA compiler pipeline is conceptually a function from programs to programs, where the actual representation may change. Pipelines can be composed using their / instance.futhark5Configuration object for running a compiler pipeline.futhark3A compilation always ends with some kind of action.futharkThe main Futhark compiler driver monad - basically some state tracking on top if ..futharkHow much information to print to stderr while the compiler is running.futharkSilence is golden.futhark+Print messages about which pass is running.futhark'Also print logs from individual passes.futharkRun a  action.futhark&Run the pipeline on the given program.futhark1Construct a pipeline from a single compiler pass.futhark(Create a pipeline from a list of passes."ANone"futharkThe compiler configuration. This only contains options related to core compiler functionality, such as reading the initial program and running passes. Options related to code generation are handled elsewhere.futhark Warn if True.futharkIf true, error on any warnings.futharkIf True, ignore unsafe.futharkThis simplistic rule is only valid before we introduce memory.MNone->?QfutharkMake a hoisted Op safe. The SubExp is a boolean that is true when the value of the statement will actually be used.futhark+Blocker for hoisting out of parallel loops.futhark-Blocker for hoisting out of sequential loops.futhark%Blocker for hoisting out of branches.futharkIndicate in the symbol table that we have descended into a loop.futharkSimplify a single body.0NNone?Sfuthark Simplify a  $, including copy propagation. If a   refers to a name that is a , the node turns into a  .futharkLike , but where leaves may be s.ONone-?VFfutharkSimplify the given program. Even if the output differs from the output, meaningful simplification may not have taken place - the order of bindings may simply have been rearranged.futhark.Run a simplification operation to convergence.futharkSimplify the given function. Even if the output differs from the output, meaningful simplification may not have taken place - the order of bindings may simply have been rearranged. Runs in a loop until convergence.futharkSimplify just a single  .futharkSimplify a sequence of  s.PNone-?WWfuthark*Run copy propagation on an entire program.futhark(Run copy propagation on some statements.futhark#Run copy propagation on a function.QNone>Wfuthark,The phantom type for the Seq representation.futharkSimplify a sequential program. svwy x RNone  ->?v)futharkLike  , but just for s.futhark)How to compute a single reduction result.futhark$How to compute a single scan result.futharkThe essential parts of a 4 factored out (everything except the input arrays).futharkWhat kind of stream is this?futharkIs the stream chunk required to correspond to a contiguous subsequence of the original input ( ) or not?  streams can be more efficient, but not all algorithms work with this.futhark/Information about computing a single histogram.futhark Race factor RF means that only 1/RF bins are used.futhark'A second-order array combinator (SOAC).futhark Scatter  length  lambda  inputs outputsScatter maps values from a set of input arrays to indices and values of a set of output arrays. It is able to write multiple values to multiple outputs each of which may have multiple dimensions. inputs, is a list of input arrays, all having size  length(, elements of which are applied to the  lambda3 function. For instance, if there are two arrays,  lambda3 will get two values as input, one from each array. outputs specifies the result of the  lambda and which arrays to write to. Each element of the list consists of a  VName* specifying which array to scatter to, a  Shape, describing the shape of that array, and an  Int describing how many elements should be written to that array for each invocation of the  lambda. lambda& is a function that takes inputs from  inputs> and returns values according to the output-specification in  outputs-. It returns values in the following manner: >index_0, index_1, ..., index_n, value_0, value_1, ..., value_mFor each output in  outputs,  lambda returns  i *  j index values and  j output values, where  i> is the number of dimensions (rank) of the given output, and  j= is the number of output values written to the given output.6For example, given the following output specification:  ([x1, y1, z1 , 2, arr1), ([x2, y2], 1, arr2)] lambda> will produce 6 (3 * 2) index values and 2 output values for  arr1, and 2 (2 * 1) index values and 1 output value for arr2. Additionally, the results are grouped, so the first 6 index values will correspond to the first two output values, and so on. For this example,  lambda should return a total of 11 values, 8 index values and 3 output values.futhark Hist  length  dest-arrays-and-ops  bucketfun inputarraysThe first SubExp is the length of the input arrays. The first list describes the operations to perform. The  : is the bucket function. Finally comes the input images.futhark7A combination of scan, reduction, and map. The first ! is the size of the input arrays.futhark1How many reduction results are produced by these s?futhark5Combine multiple scan operators to a single operator.futhark1How many reduction results are produced by these s?futhark:Combine multiple reduction operators to a single operator.futharkThe types produced by a single %, given the size of the input array.futharkConstruct a lambda that takes parameters of the given types and simply returns them unchanged.futhark'Is the given lambda an identity lambda?futhark3A lambda with no parameters that returns no values.futharkConstruct a Screma with possibly multiple scans, and the given map function.futharkConstruct a Screma with possibly multiple reductions, and the given map function.futharkConstruct a Screma with possibly multiple scans, and identity map function.futharkConstruct a Screma with possibly multiple reductions, and identity map function.futhark*Construct a Screma corresponding to a map.futhark6Does this Screma correspond to a scan-map composition?futhark)Does this Screma correspond to pure scan?futhark8Does this Screma correspond to a reduce-map composition?futhark-Does this Screma correspond to a pure reduce?futharkDoes this Screma correspond to a simple map, without any reduction or scan results?futharkReturn the "main" lambda of the Screma. For a map, this is equivalent to . Note that the meaning of the return value of this lambda depends crucially on exactly which Screma this is. The parameters will correspond exactly to elements of the input arrays, however.futhark groupScatterResults  output specification results-Groups the index values and result values of  results according to the  output specification.This function is used for extracting and grouping the results of a scatter. In the SOAC representation, the lambda inside a  returns all indices and values as one big list. This function groups each value with its corresponding indices (as determined by the  of the output array).The elements of the resulting list correspond to the shape and name of the output parameters, in addition to a list of values written to that output parameter, along with the array indices marking where to write them to.See  for more information.futhark groupScatterResults'  output specification results-Groups the index values and result values of  results according to the output specification. This is the simpler version of groupScatterResults, which doesn't return any information about shapes or output arrays.See  for more information,futhark splitScatterResults  output specification resultsSplits the results array into indices and values according to the output specification.See  for more information.futhark/A mapper that simply returns the SOAC verbatim.futharkMap a monadic action across the immediate children of a SOAC. The mapping does not descend recursively into subexpressions and is done left-to-right.futharkA helper for defining  .futharkThe type of a SOAC.futharkType-check a SOAC.futharkPrettyprint the given Screma.futhark*Prettyprint the given histogram operation.??SNone?zfutharkTurns a binding of a redomap into two seperate bindings, a map binding and a reduce" binding (returned in that order).$Reuses the original pattern for the reduce&, and creates a new pattern with new s for the result of the map.futharkTurn a Screma into a Scanomap (possibly with mapout parts) and a Redomap. This is used to handle Scremas that are so complicated that we cannot directly generate efficient parallel code for them. In essense, what happens is the opposite of horisontal fusion.futharkTurn a stream SOAC into statements that apply the stream lambda to the entire input.futharkSplit the parameters of a stream reduction lambda into the chunk size parameter, the accumulator parameters, and the input chunk parameters. The integer argument is how many accumulators are used.  TNone>}futhark%The rep for the basic representation. svwy x  svwy x UNone-?RfutharkThe constraints that a monad must uphold in order to be used for first-order transformation.futharkThe constraints that must hold for a rep in order to be the target of first-order transformation.futharkFirst-order-transform a single function, with the given scope provided by top-level constants.futhark0First-order-transform these top-level constants.futharkFirst transform any nested  or  elements, then apply  if the expression is a SOAC.futharkTransform a single  into a do-loop. The body of the lambda is untouched, and may or may not contain further s depending on the given rep.futhark+Recursively first-order-transform a lambda.VNone?futhark$The first-order transformation pass.WNone?"futhark1Interchange Scan With Inner Map. Tries to turn a  scan(map) into a @map(scan)futhark3Interchange Reduce With Inner Map. Tries to turn a  reduce(map) into a @map(reduce)futharkDoes this reduce operator contain an inner map, and if so, what does that map look like? Trustworthy  >futharkA mapping from external variable names to the corresponding internalised subexpressions.futhark;Add a function definition to the program being constructed.futhark Construct an   statement, but taking attributes into account. Always use this function, and never construct   directly in the internaliser! r rXNone?futharkReshape the arguments to a function so that they fit the expected shape declarations. Not used to change rank of arguments. Assumes everything is otherwise type-correct.YNone >?futharkDoes this rep contain  s in its  s? A rep must be an instance of this class for the simplification rules to work.futharkRemove all arguments to the map that are simply replicates. These can be turned into free variables instead.ZNone yfutharkThe call graph is a mapping from a function name, i.e., the caller, to a record of the names of functions called *directly* (not transitively!) by the function.>We keep track separately of the functions called by constants.futhark.Is the given function known to the call graph?futhark(Does the first function call the second?futhark/Is the function called in any of the constants?futhark&All functions called by this function.futharkbuildCallGraph prog build the program's call graph.futharkProduce a mapping of the number of occurences in the call graph of each function. Only counts functions that are called at least once.futharkThe set of all functions that are called noinline somewhere, or have a noinline attribute on their definition.[None  ->?futharkThe memory return of a function, which must always indicate where returned arrays are located.futharkThe return of a body, which must always indicate where returned arrays are located.futharkThe memory return of an expression. An array is annotated with Maybe MemReturn, which can be interpreted as the expression either dictating exactly where the array is located when it is returned (if /8), or able to put it whereever the binding prefers (if .).This is necessary to capture the difference between an expression that is just an array-typed variable, in which the array being "returned" is located where it already is, and a copy expression, whose entire purpose is to store an existing array in some arbitrary location. This is a consequence of the design decision never to have implicit memory copies.futharkA description of the memory properties of an array being returned by an operation.futharkThe array is located in a memory block that is already in scope.futhark8The operation returns a new (existential) memory block.futhark?Memory information for an array bound somewhere in the program.futhark7Located in this memory block with this index function.futharkA summary of the memory information for every let-bound identifier, function parameter, and return value. Parameterisered over uniqueness, dimension, and auxiliary array information.futharkA primitive value.futharkA memory block.futharkThe array is stored in the named memory block, and with the given index function. The index function maps indices in the array to element offset, not byte offsets! To translate to byte offsets, multiply the offset with the size of the array element type.futhark-An accumulator, which is not stored anywhere.futhark9An index function that may contain existential variables.futhark>The index function representation used for memory annotations.futharkAllocate a memory block.futharkThe class of pattern element decorators that contain memory information.futharkA helper for defining  .futharkThe return information of an expression. This can be seen as the "return type with memory annotations" of the expression. svwy x .\None->?futhark2Monad for adding allocations to an entire program.futharkAggressively try to reuse memory in do-loops - should be True inside kernels, False outside.futharkWhen allocating memory, put it in this memory space. This is primarily used to ensure that group-wide statements store their results in local memory.futharkThe set of names that are known to be constants at kernel compile time.futharkA mapping from chunk names to their maximum size. XXX FIXME HACK: This is part of a hack to add loop-invariant allocations to reduce kernels, because memory expansion does not use range analysis yet (it should).futharkThe subexpression giving the number of elements we should allocate space for. See  comment.futhark.Allocate memory for a value of the given type.//////////////////.////////////////////////////// //////////////// ]None  -2>?'futharkDoes this rep contain  s in its  s? A rep must be an instance of this class for the simplification rules to work.futharkLike  , but just for s.futharkA  is semantically a perfectly nested stack of maps, on top of some bottommost computation (scalar computation, reduction, scan, or histogram). The % encodes the original map structure.All s are parameterised by the representation of their body, as well as a *level*. The *level* is a representation-specific bit of information. For example, in GPU backends, it is used to indicate whether the < is expected to run at the thread-level or the group-level.futharkThe KernelSpace must always have at least two dimensions, implying that the result of a SegRed is always an array.futharkIndex space of a .futharkFlat physical index corresponding to the dimensions (at code generation used for a thread ID or similar).futharkDo we need group-virtualisation when generating code for the segmented operation? In most cases, we do, but for some simple kernels, we compute the full number of groups in advance, and then virtualisation is an unnecessary (but generally very small) overhead. This only really matters for fairly trivial but very wide map kernels where each thread performs constant-time work on scalars.futharkNot only do we not need virtualisation, but we _guarantee_ that all physical threads participate in the work. This can save some checks in code generation.futharkA  does not return an ordinary  (. Instead, it returns a list of these.futharkEach "worker" in the kernel returns this. Whether this is a result-per-thread or a result-per-group depends on where the  occurs.futhark8Metadata about whether there is a subtle point to this . This is used to protect things like tiling, which might otherwise be removed by the simplifier because they're semantically redundant. This has no semantic effect and can be ignored at code generation.futharkDon't simplify this one!futharkGo nuts.futharkThe results produced are only used within the same physical thread later on, and can thus be kept in registers.futharkThe body of a .futharkAn operator for  and .futharkIn case this operator is semantically a vectorised operator (corresponding to a perfect map nest in the SOACS representation), these are the logical "dimensions". This is used to generate more efficient code.futharkAn operator for .futharkIn case this operator is semantically a vectorised operator (corresponding to a perfect map nest in the SOACS representation), these are the logical "dimensions". This is used to generate more efficient code.futhark"How an array is split into chunks.futhark&The type of a histogram produced by a /. This can be different from the type of the 5s in case we are dealing with a segmented histogram.futhark1How many reduction results are produced by these s?futharkSplit some list into chunks equal to the number of values returned by each futharkGet the certs for this .futhark Get the root  corresponding values for a .futharkPerform alias analysis on a .futhark*The variables consumed in the kernel body.futhark(The sizes spanned by the indexes of the .futharkA  < containing all the identifiers brought into scope by this .futharkThe level of a .futharkThe space of a .futharkThe body of a .futhark Type check a  , given a checker for its level.futhark!A mapper that simply returns the  verbatim.futharkApply a  to the given .futharkA helper for defining  .futharkSimplify the given .futhark%Simplification rules for simplifying s.futharkLike /!, but for memory representations.^None-?futhark?futharkNote: first element is *outermost* nesting. This is different from the similar types elsewhere!futharkFirst pair element is the very innermost ("current") target. In the list, the outermost target comes first. Invariant: Every element of a pattern must be present as the result of the immediately enclosing target. This is ensured by & by removing unused pattern elements.futhark&Retrieve the innermost kernel nesting.futharkAdd new outermost nesting, pushing the current outermost to the list, also taking care to swap patterns if necessary.futharkAdd new innermost nesting, pushing the current outermost to the list. It is important that the  has the right order (non-permuted compared to what is expected by the outer nests).futharkFlatten a kernel nesting to: The index space.:The kernel inputs - note that some of these may be unused.))`None?futharkAn encoding of a sequential do-loop with no existential context, alongside its result pattern.futharkGiven a (parallel) map nesting and an inner sequential loop, move the maps inside the sequential loop. The result is several statements - one of these will be the loop, which will then contain statements with map expressions.  aNone >?r!!bNone ->?wfutharkSome constraints that must hold for the simplification rules to work.cNone ->?Ƴ svwy x dNone>?̪eNone ?^futharkAn operation for the multicore representation. Feel free to extend this on an ad hoc basis as needed. Parameterised with some other operation.futhark The first  (if it exists) contains nested parallelism, while the second one has a fully sequential body. They are semantically fully equivalent.futhark*Something else (in practice often a SOAC).fNone ->?; svwy x gNone> svwy x :hNone ->? futhark=A host-level operation; parameterised by what else it can do.futharkA segmented operation.futhark)A simple size-level query or computation.futhark!SplitSpace o w i elems_per_thread.Computes how to divide array elements to threads in a kernel. Returns the number of elements in the chunk that the current thread should take.w5 is the length of the outer dimension in the array. i: is the current thread index. Each thread takes at most elems_per_thread elements. If the order o is , thread with index i should receive elements i*elems_per_tread, i*elems_per_thread + 1, ..., i*elems_per_thread + (elems_per_thread-1). If the order o is  stride$, the thread will receive elements =i, i+stride, i+2*stride, ..., i+(elems_per_thread-1)*stride.futhark'Produce some runtime-configurable size.futharkThe maximum size of some class.futhark:Compare size (likely a threshold) with some integer value.futhark)CalcNumGroups w max_num_groups group_size calculates the number of GPU workgroups to use for an input of the given size. The Name is a size name. Note that w% is an i64 to avoid overflow issues.futharkAt which level the *body* of a  executes.futharkA helper for defining  . iNone>Mfuthark5The phantom data type for the kernels representation. svwy x 9jNone?.futharkThe pass definition.kNone-?WlNone futhark4Transform a program using SOACs to a program in the 2 representation, using some amount of flattening.mNone-?futharkLike , but cap the thread count to the input size. This is more efficient for small kernels, e.g. summing a small array.nNone >?futharkConvert the statements inside a map nest to kernel statements, attempting to parallelise any remaining (top-level) parallel statements. Anything that is not a map, scan or reduction will simply be sequentialised. This includes sequential loops that contain maps, scans or reduction. In the future, we could probably do something more clever. Make sure that the amount of parallelism to be exploited does not exceed the group size. Further, as a hack we also consider the size of all intermediate arrays as "parallelism to be exploited" to avoid exploding local memory.We distinguish between "minimum group size" and "maximum exploitable parallelism".oNone >?nfutharkTransform a program using SOACs to a program using explicit kernels, using the kernel extraction transformation.pNonefutharkThe variance table keeps a mapping from a variable name (something produced by a  ) to the kernel thread indices that name depends on. If a variable is not present in this table, that means it is bound outside the kernel (and so can be considered invariant to all dimensions).qNone-?PfutharkSinking in GPU kernels.futharkSinking for multicore.rNone?futharkName of result.futharkType of result.  sNone ->?futhark>Apply the in-place lowering optimisation to the given program.futhark>Apply the in-place lowering optimisation to the given program.futhark>Apply the in-place lowering optimisation to the given program.tNone>?futharkThe operations that permit CSE.futhark+Perform CSE on every function in a program.If the boolean argument is false, the pass will not perform CSE on expressions producing arrays. This should be disabled when the rep has memory information, since at that point arrays have identity beyond their value.futhark!Perform CSE on a single function.If the boolean argument is false, the pass will not perform CSE on expressions producing arrays. This should be disabled when the rep has memory information, since at that point arrays have identity beyond their value.futharkPerform CSE on some statements.If the boolean argument is false, the pass will not perform CSE on expressions producing arrays. This should be disabled when the rep has memory information, since at that point arrays have identity beyond their value.uNone ?futhark=Inline all functions and remove the resulting dead functions.futhark>Inline some functions and remove the resulting dead functions.futharkremoveDeadFunctions prog removes the functions that are unreachable from the main function from the program.vNone?futharkExpects a kernel statement as argument. CONDITIONS for 3D tiling optimization to fire are: 1. a) The kernel body can be broken into scalar-code-1 ++ [Redomap stmt] ++ scalar-code-2. b) The kernels has a per-thread result, and obviously the result is variant to the 3rd dimension (counted from innermost to outermost) 2. For the Redomap: a) the streamed arrays are one dimensional b) each of the array arguments of Redomap are variant to exactly one of the three innermost-parallel dimension of the kernel. This condition can be relaxed by interchanging kernel dimensions whenever possible. 3. For scalar-code-1: a) each of the statements is a slice that produces one of the streamed arraysmmBlkRegTiling :: Stm GPU -> TileM (Maybe (Stms GPU, Stm GPU)) mmBlkRegTiling (Let pat aux (Op (SegOp (SegMap SegThread{} seg_space ts old_kbody))))wNone?VfutharkThe pass definition.xNone ->?yNone?futharkThe pass for GPU kernels.futharkThe pass for multicore.zNone ->?< svwy x {None?|None>?W}None>?futharkThe pass from  to .~None>?KfutharkThe pass from  to .futhark Convert some  stms to .None?futhark%The memory expansion pass definition.None ->?0futharkThe pass for GPU kernels.futharkThe pass for multicoreNone ?ZNone?Ofuthark tells which names were last used in a given statement. Statements are uniquely identified by the 9 of the first value parameter in the statement pattern.   is the set of names last used.futharkAnalyses a program to return a last-use map, mapping each simple statement in the program to the values that were last used within that statement, and the set of all  that were used inside.None-? futhark"An interference graph. An element (x, y)< in the set means that there is an undirected edge between x and y!, and therefore the lifetimes of x and y overlap and they "interfere" with each other. We assume that pairs are always normalized, such that x < y, before inserting. This should prevent any duplicates. We also don't allow any pairs where x == y.futharkPerform interference analysis on the given statements. The result is a triple of the names currently in use, names that hit their last use somewhere within, and the resulting graph.None ifuthark9A map of values to their color, identified by an integer.futhark+Graph coloring that takes into account the space of values. Two values can only share the same color if they live in the same space. The result is map from each color to a space and a map from each value in the input graph to it's new color.None%-? futhark+Perform the reuse-allocations optimization.None>*futhark8The reason why some expression cannot be converted to a  value.futhark,The expression is not a (tuple-)SOAC at all.futhark/A definite representation of a SOAC expression.futharkOne array input to a SOAC - a SOAC may have multiple inputs, but all are of this form. Only the array inputs are expressed with this type; other arguments, such as initial accumulator values, are plain expressions. The transforms are done left-to-right, that is, the first element of the  list is applied first.futhark0A view of the last transformation to be applied.futhark1A view of the first transformation to be applied.futhark:A sequence of array transformations, heavily inspired by Data.Seq. You can decompose it using  and , and grow it by using  and . These correspond closely to the similar operations for sequences, except that appending will try to normalise and simplify the transformation sequence.The data type is opaque in order to enforce normalisation invariants. Basically, when you grow the sequence, the implementation will try to coalesce neighboring permutations, for example by composing permutations and removing identity transformations.futharkA single, simple transformation. If you want several, don't just create a list, use  instead.futhark*A permutation of an otherwise valid input.futhark(A reshaping of an otherwise valid input.futhark#A reshaping of the outer dimension.futhark2A reshaping of everything but the outer dimension.futhark2Replicate the rows of the array a number of times.futharkThe empty transformation list.futhark#Is it an empty transformation list?futhark7Decompose the input-end of the transformation sequence.futhark8Decompose the output-end of the transformation sequence.futhark6Add a transform to the end of the transformation list.futharkA07futhark"Phantom type for a count of bytes.futhark%Phantom type for a count of elements.futharkA function call argument.futharkLike !, but with a required/known type.futharkA side-effect free expression whose execution will produce a single primitive value.futharkThe volatility of a memory access or variable. Feel free to ignore this for backends where it makes no sense (anything but C and similar low-level things)futhark1A block of imperative code. Parameterised by an , which allows extensibility. Concrete uses of this type will instantiate the type parameter with e.g. a construct for launching GPU kernels.futharkNo-op. Crucial for the / instance.futhark(Statement composition. Crucial for the / instance.futharkA for-loop iterating the given number of times. The loop parameter starts counting from zero and will have the same (integer) type as the bound. The bound is evaluated just once, before the loop is entered.futharkWhile loop. The conditional is (of course) re-evaluated before every iteration of the loop.futharkDeclare a memory block variable that will point to memory in the given memory space. Note that this is distinct from allocation. The memory block must be the target of either an  or a / before it can be used for reading or writing.futhark{futhark(Generate Futhark server executable code. Trustworthy >{futhark,Generate Futhark standalone executable code. Trustworthy >$futharkThe result of compilation to C is multiple parts, which can be put together in various ways. The obvious way is to concatenate all of them, which yields a CLI program. Another is to compile the library part by itself, and use the header file to call into it.futharkUtility definitions that must be visible to both CLI and library parts.futharkThe manifest, in JSON format.futhark?% futharkThe program described by a single Futhark file. May depend on other files. futharkA top-level binding. futharkA module parameter. futharkA module binding. futharkModule expression. futhark)The contents of another file as a module. futharkFunctor application. The first mapping is from parameter names to argument names, while the second maps names in the constructed module to the names inside the functor. futharkModule type binding. futharkA type refinement. futharkA module type expression. futhark'A spec is a component of a module type. futharkAbstract type. futharkA type parameter. futhark%A type parameter that must be a size. futhark%A type parameter that must be a type. futhark,The liftedness of a type parameter. By the Ord instance, Unlifted < SizeLifted < Lifted. futharkMay only be instantiated with a zero-order type of (possibly symbolically) known size. futharkMay only be instantiated with a zero-order type, but the size can be varying. futhark+May be instantiated with a functional type. futharkType Declarations futharkFunction Declarations futharkJust if this function is an entry point. If so, it also contains the externally visible interface. Note that this may not strictly be well-typed after some desugaring operations, as it may refer to abstract types that are no longer in scope. futharkIf   is null, then the "' are brought into scope at this point.!futharkInformation about the external interface exposed by an entry point. The important thing is that that we remember the original source-language types, without desugaring them at all. The annoying thing is that we do not require type annotations on entry points, so the types can be either ascribed or inferred.!futharkA parameter of an entry point.!futharkPart of the type of an entry point. Has an actual type, and maybe also an ascribed type expression.!futhark1Documentation strings, including source location.!futharkA pattern as used most places where variables are bound (function parameters, let expressions, etc).!futharkA literal in a pattern.!futharkWhether the loop is a for -loop or a while-loop.!futharkA case in a match expression.!futharkAn entry in a record literal.!futhark The Futhark expression language.This allows us to encode whether or not the expression has been type-checked in the Haskell type of the expression. Specifically, the parser will produce expressions of type Exp " ., and the type checker will convert these to Exp " , in which type information is always present and all names are unique.!futharkA polymorphic integral literal.!futharkA polymorphic decimal literal.!futhark?A string literal is just a fancy syntax for an array of bytes.!futharkA parenthesized expression.!futharkTuple literals, e.g., {1+3, {x, y+z}}.!futharkRecord literals, e.g.  {x=2,y=3,z}.!futharkArray literals, e.g., [ [1+x, 3], [2, 1+4] ]7. Second arg is the row type of the rows of the array.!futhark1An attribute applied to the following expression.!futhark;Numeric negation (ugly special case; Haskell did it first).!futharkLogical and bitwise negation.!futharkFail if the first expression does not return true, and return the value of the second expression if it does.!futharkAn n-ary value constructor.!futhark+0; first two types are operands, third is result.!futhark2+*; first type is operand, second is result.!futhark+2*; first type is operand, second is result.!futharkField projection as a section: (.x.y.z).!futharkArray indexing as a section: (.[i,j]).!futharkType ascription: e : t.!futharkAn annotation inserted by the type checker on constructs that are "function calls" (either literally or conceptually). This annotation encodes the result type, as well as any existential sizes that are generated here.!futharkAn "application expression" is a semantic (not syntactic) grouping of expressions that have "funcall-like" semantics, mostly meaning that they can return existential sizes. In our type theory, these are all thought to be bound to names (*Administrative Normal Form*), but as this is not practical in a real language, we instead use an annotation (!) that stores the information we need, so we can pretend that an application expression was really bound to a name.!futharkThe  Maybe VName is a possible existential size that is instantiated by this argument. May have duplicates across the program, but they will all produce the same value (the expressions will be identical).!futharkSize coercion: e :> t.!futharkA match expression.!futharkA binding of a size in a pattern (essentially a size parameter in a let expression).!futhark6A name qualified with a breadcrumb of module accesses.!futhark8A slicing of an array (potentially multiple dimensions).!futhark"An indexing of a single dimension.!futhark&Whether a bound for an end-point of a !/ or a range literal is inclusive or exclusive.!futhark%May be "down to" if step is negative.!futharkDefault binary operators.!futharkA pseudo-operator standing in for any normal identifier used as an operator (they all have the same fixity). Binary Ops for Numbers!futhark |>!futhark<| Misc!futharkAn identifier consists of its name and the type of the value bound to the identifier."futharkSimple Futhark values. Values are fully evaluated and their type is always unambiguous."futharkIt is assumed that the array is 0-indexed. The type is the full type."futhark;Information about which parts of a value/type are consumed."futhark$Consumes these fields in the record."futhark(Consume these parts of the constructors."futhark?A function that consumes its argument(s) like this. The final " should always be ", as there is no way for a function to consume its return value."futharkConsumes this value."futhark8Only observes value in this position, does not consume."futhark'A declaration of the type of something."futharkThe type declared by the user."futhark%The type deduced by the type checker."futhark8A type argument expression passed to a type constructor."futharkAn unstructured type with type variables and possibly shape declarations - this is what the user types in the source program. These are used to construct "s in the type checker."futhark0A dimension declaration expression for use in a "."futharkThe size of the dimension is this name, which must be in scope."futharkThe size is a constant."futharkNo dimension declaration."futharkThe return type version of "."futharkThe return type version of "."futhark6A value type contains full, manifest size information."futharkA "structural" type with shape annotations and no aliasing information, used for declarations."futharkA type with aliasing information and shape annotations, used for describing the type patterns and expressions."futharkAliasing for a type, which is a set of the variables that are aliased."futharkA variable that is aliased. Can be still in-scope, or have gone out of scope and be free. In the latter case, it behaves more like an equivalence class. See uniqueness-error18.fut for an example of why this is necessary."futhark)An argument passed to a type constructor."futharkAn expanded Futhark type is either an array, or something that can be an element of an array. When comparing types for equality, function parameter names are ignored. This representation permits some malformed types (arrays of functions), but importantly rules out arrays-of-arrays."futharkTypes that can be elements of arrays. This representation does allow arrays of records of functions, which is nonsensical, but it convolutes the code too much if we try to statically rule it out."futharkThe aliasing corresponds to the lexical closure of the function."futharkTypes that can appear to the right of a function arrow. This just means they can be existentially quantified."futhark0The name (if any) of a function parameter. The / and /5 instances always compare values of this type equal."futhark?A type name consists of qualifiers (for error messages) and a  (for equality checking)."futharkThe size of an array type is a list of its dimension sizes. If .3, that dimension is of a (statically) unknown size."futhark Declaration of a dimension size."futharkThe size of the dimension is this name, which must be in scope. In a return type, this will give rise to an assertion."futharkThe size is a constant."futharkNo known size - but still possibly given a unique name, so we can recognise e.g. type square [n] = [n][n]i32 and make  square [] do the right thing. If Nothing, then this is a name distinct from any other. The type checker should _never_ produce these - they are a (hopefully temporary) thing introduced by defunctorisation and monomorphisation."futhark5A type class for things that can be array dimensions."futhark unifyDims x y combines x and y to contain their maximum common information, and fails if they conflict."futharkThe payload of an attribute."futharkThe value of an "."futharkA class for converting ordinary Haskell values to primitive Futhark values."futharkNon-array values."futharkLow-level primitive types."futharkSome information. The dual to ""futharkNo information functor. Usually used for placeholder type- or aliasing information."futharkConvenience class for deriving / instances for the AST."futhark.The number of dimensions contained in a shape."futharkstripDims n shape strips the outer n dimensions from shape , returning .3 if this would result in zero or fewer dimensions."futhark Convert a ! to a "."futhark Convert a " to a !."futharkThe name of a type parameter. svwy x !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !! !!!!!!!!!!!!!!! " """""""""""!!!! Safe-Inferred >? $futhark8A case (of a match expression) with no type annotations.$futhark+A Futhark program with no type annotations.$futhark A spec with no type annotations.$futhark'A declaration with no type annotations.$futhark0A function declaration with no type annotations.$futhark#A pattern with no type annotations.$futhark*A type parameter with no type annotations.$futhark2A module type expression with no type annotations.$futhark-A module expression with no type annotations.$futhark'An expression with no type annotations.$futhark!A slice with no type annotations.$futhark"An index with no type annotations.$futhark'An identifier with no type annotations.$futhark)A type declaration with no expanded type.$futhark'An expression with no type annotations.$futhark:A type with no aliasing information but shape annotations.$futharkThe nature of something predefined. For functions, these can either be monomorphic or overloaded. An overloaded builtin is a list valid types it can be instantiated with, to the parameter and result type, with .- representing the overloaded parameter type.$futhark Where does this dimension occur?$futharkImmediately in the argument to $.$futharkIn a function parameter type.$futharkIn a function return type.$futharkReturn the dimensionality of a type. For non-arrays, this is zero. For a one-dimensional array it is one, for a two-dimensional it is two, and so forth.$futhark5Return the shape of a type - for non-arrays, this is /.$futharkReturn any free shape declarations in the type, with duplicates removed.$futhark/Change the shape of a type to be just the rank.$futharkPerform a traversal (possibly including replacement) on sizes that are parameters in a function type, but also including the type immediately passed to the function. Also passes along a set of the parameter names inside the type that have come in scope at the occurrence of the dimension.$futharkFigure out which of the sizes in a parameter type must be passed explicitly, because their first use is as something else than just an array dimension. $ is like this function, but first decomposes into parameter types.$futharkFigure out which of the sizes in a binding type must be passed explicitly, because their first use is as something else than just an array dimension.$futhark Return the uniqueness of a type.$futharkunique t is /' if the type of the argument is unique.$futharkReturn the set of all variables mentioned in the aliasing of a type.$futharkdiet t< returns a description of how a function parameter of type t might consume its argument.$futharkConvert any type to one that has rank information, no alias information, and no embedded names.$futhark(Remove aliasing information from a type.$futhark,Replace no aliasing with an empty alias set.$futhark peelArray n t4 returns the type resulting from peeling the first n array dimensions from t . Returns Nothing if t has less than n dimensions.$futhark arrayOf t s u constructs an array type. The convenience compared to using the " constructor directly is that t can itself be an array. If t is an n-dimensional array, and s is a list of length n, the resulting type is of an n+m6 dimensions. The uniqueness of the new array will be u, no matter the uniqueness of t.$futharkstripArray n t removes the n outermost layers of the array. Essentially, it is the type of indexing an array of type t with n indexes.$futharkCreate a record type corresponding to a tuple with the given element types.$futharkDoes this type corespond to a tuple? If so, return the elements of that tuple.$futhark+Does this record map correspond to a tuple?$futhark0Construct a record map corresponding to a tuple.$futhark1Increasing field names for a tuple (starts at 0).$futharkSort fields by their name; taking care to sort numeric fields by their numeric value. This ensures that tuples and tuple-like records match.$futharkSort the constructors of a sum type in some well-defined (but not otherwise significant) manner.$futhark Is this a  ?$futhark Is this a  ?$futharkCombine the shape information of types as much as possible. The first argument is the orignal type and the second is the type of the transformed expression. This is necessary since the original type may contain additional information (e.g., shape restrictions) from the user given annotation.$futharkMatch the dimensions of otherwise assumed-equal types. The combining function is also passed the names bound within the type (from named parameters or return types).$futharkSet the uniqueness attribute of a type. If the type is a record or sum type, the uniqueness of its components will be modified.$futharkt `setAliases` als returns t , but with als/ substituted for any already present aliasing.$futharkt `addAliases` f returns t5, but with any already present aliasing replaced by f applied to that aliasing.$futharkThe type of a basic value.$futharkThe type of the value.$futharkThe type of an Futhark term. The aliasing will refer to itself, if the term is a non-tuple-typed variable.$futharkfoldFunType ts ret creates a function type (") that takes ts as parameters and returns ret.$futharkExtract the parameter types and return type from a type. If the type is not an arrow type, the list of parameter types is empty.$futharkThe type scheme of a value binding, comprising the type parameters and the actual type.$futharkThe names that are brought into scope by this value binding (not including its own parameter names, but including any existential sizes).$futharkThe type of a function with the given parameters and return type.$futhark#The type names mentioned in a type.$futhark orderZero t is / if the argument type has order 0, i.e., it is not a function type, does not contain a function type as a subcomponent, and may not be instantiated with a function type.$futhark:Extract all the shape names that occur in a given pattern.$futhark?U%futharkClass for type constructors that represent annotations. Used in the prettyprinter to either print the original AST, or the computed decoration.%futharkExtract value, if any.%futharkA class for types that are variable names in the Futhark source language. This is used instead of a mere . instance because in the compiler frontend we want to print VNames differently depending on whether the FUTHARK_COMPILER_DEBUGGING environment variable is set, yet in the backend we want to always print VNames with the tag. To avoid erroneously using the . instance for VNames, we in fact only define it inside the modules for the core language (as an orphan instance).%futharkPrettyprint a name to a string.%futharkDepending on the environment variable FUTHARK_COMPILER_DEBUGGING, VNames are printed as either the name with an internal tag, or just the base name.%%%%%%%%%%%% Trustworthy %futharkA lexical token. It does not itself contain position information, so in practice the parser will consume tokens tagged with a source position.&futhark&A value tagged with a source location.&futharkGiven a starting position, produce tokens from the given text (or a lexer error). Returns the final position.%&&%&&%%%%%&&&&&&&&&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&/ Trustworthy >&futharkA parse error. Use /% to get a human-readable description.&futharkParse either an expression or a declaration incrementally; favouring declarations in case of ambiguity. &&////////&/9 /9  Safe-Inferred&futhark/Parse an entire Futhark program from the given . , using the .' as the source name for error messages.&futhark+Parse an Futhark expression from the given . , using the .' as the source name for error messages.&futhark1Parse a Futhark module expression from the given . , using the .' as the source name for error messages.&futhark%Parse an Futhark type from the given . , using the .' as the source name for error messages.&futhark'Parse any Futhark value from the given . , using the .( as the source name for error messages.&futharkParse several Futhark values (separated by anything) from the given . , using the .( as the source name for error messages.%&&%&&%%%%%&&&&&&&&&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&%&&%&&%%%%%&&&&&&&&&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%& Safe-Inferred&futhark,A type-checked case (of a match expression).&futhark.A known scalar type with no shape annotations.&futharkA type-checked type parameter.&futhark(A known type arg with shape annotations.&futhark)An Futhark program with type information.&futharkA type-checked specification.&futharkA type-checked declaration.&futhark&A type-checked module type expression.&futhark A type-checked module parameter.&futhark!A type-checked module expression.&futhark#A type-checked module type binding.&futharkA type-checked module binding.&futhark%A type binding with type information.&futhark(A type declaration with type information&futhark.An constant declaration with type information.&futhark A pattern with type information.&futhark0An application expression with type information.&futhark$An expression with type information.&futharkA slice with type information.&futharkAn index with type information.&futhark2An identifier with type- and aliasing information. svwy x !!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& Safe-InferredT&futhark6Modules produces environment with this representation.&futharkA mapping from names (which always exist in some namespace) to a unique (tagged) name.&futharkType parameters, list of parameter types (optinally named), and return type. The type parameters are in scope in both parameter types and the return type. Non-functional values have only a return type.&futharkA binding from a name to its definition as a type. We allow a return type here to support type abbreviations that hide some inner sizes (these must necessarily be   or  ).&futhark Representation of a module type.&futhark"Abstract types in the module type.&futharkA parametric functor consists of a set of abstract types, the environment of its parameter, and the resulting module type.&futharkRepresentation of a module, which is either a plain environment, or a parametric module ("functor" in SML).&futhark0A mapping of abstract types to their liftedness.&futharkThe space inhabited by a name.&futharkFunctions and values.&futharkA mapping from import names to imports. The ordering is significant.&futharkThe result of type checking some file. Can be passed to further invocations of the type checker.&futharkAbstract types.&futharkCanonical reference to a Futhark code file. Does not include the .fut extension. This is most often a path relative to the current working directory of the compiler.&futharkCreate an import name immediately from a file path specified by the user.&futhark We resolve '..' paths here and assume that no shenanigans are going on with symbolic links. If there is, too bad. Don't do that.&futhark Create a .fut file corresponding to an &.&futhark7Produce a human-readable canonicalized string from an &.(&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&(&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None 567 &futharkThe interpreter context. All evaluation takes place with respect to a context, and it can be extended with more definitions, which is how the REPL works.&futharkAn error occurred during interpretation due to an error in the user program. Actual interpreter errors will be signaled with an IO exception (/).&futhark'The actual type- and value environment.&futhark A fully evaluated Futhark value.'futhark(What is the reason for this break point?'futhark&An explicit breakpoint in the program.'futharkA'futhark,Does the value correspond to an empty array?'futharkString representation of an empty array with the provided element type. This is pretty ad-hoc - don't expect good results unless the element type is a primitive.'futharkThe initial environment contains definitions of the various intrinsic functions.'futharkExecute the named function on the given arguments; may fail horribly if these are ill-typed.&&&&&&&&&&&&&&''''''''''''''''&&&&&&'''''&&&&''''''''&&&&''' Trustworthy?'futharkAs '>, but returns components of a top-level tuple type piecemeal.'futharkHow many core language values are needed to represent one source language value of the given type?'futhark7Convert an external primitive to an internal primitive.'futharkConvert an external primitive value to an internal primitive value. '''''''''' ''''''''''None?'futhark%A function for internalising lambdas.'''''''''''' Safe-Inferred'futhark.A set of names where we also track uniqueness.'futharkSet subtraction.'futharkA ' with a single  name.'futhark3Compute the set of free variables of an expression.'futhark2Extract all the variable names bound in a pattern. ''''''''' '''''''''None?&''''''''''''None  ?'futharkConvert a program in source Futhark to a program in the Futhark core language.'' Safe-Inferred>'futhark'The class of things that we can map an ' across.'futharkMap a monadic action across the immediate children of an object. Importantly, the ' action is not invoked for the object itself, and the mapping does not descend recursively into subexpressions. The mapping is done left-to-right.'futharkExpress a monad mapping operation on a syntax node. Each element of this structure expresses the operation to be performed on a given child.'futharkAn '& that just leaves its input unchanged.'futharkRemove all annotations from an expression, but retain the name/scope information. ''''''''''''' ''''''''''''' Safe-Inferred? Z'futhark7Information about what is at the given source location.'futharkWhat a name is bound to.'futharkWhere was a bound variable actually bound? That is, what is the location of its definition?'futharkInformation about what's at the given source position. Returns . if there is nothing there, including if the source position is invalid. ut''''''''' '''''''''ut Trustworthy? (futharkPerform the transformation.(( Trustworthy '(futharkPerform defunctorisation.((None>? (futharkTransform a list of top-level value bindings. May produce new lifted function definitions, which are placed in front of the resulting list of declarations.(( Safe-Inferred  (futhark0A representation of the essentials of a pattern.(futharkFind the unmatched cases.(((( Safe-Inferred(futhark,The warnings produced by the compiler. The /1 instance produces a human-readable description.(futhark*True if there are any warnings in the set.(futhark'A single warning at the given location.(futharkA single warning at the given location, but also with a stack trace (sort of) to the location.(((((((( Trustworthy ->?/+(futharkCompile things to .(futharkCompile to an , where the type (must must still be a primitive) is deduced monadically.(futhark*Compile where we know the type in advance.(futharkA typed variable, which we can turn into a typed expression, or use as the target for an assignment. This is used to aid in type safety when doing code generation, by keeping the types straight. It is still easy to cheat when you need to.(futhark)The symbol table used during compilation.(futhark;Every non-scalar variable must be associated with an entry.(futhark6When an array is declared, this is where it is stored.(futhark,An alternate way of compiling an allocation.(futharkHow to compile an  .(futharkHow to compile some  .(futharkHow to compile an  .(futharkAn operations set for which the expression compiler always returns (.(futharkExecute a code generation action, returning the code that was emitted.(futharkExecute a code generation action, wrapping the generated code within a  with the given description.(futhark$Emit some generated imperative code.(futhark;Emit a warning about something the user should be aware of.(futhark&Emit a function in the generated code.(futhark+Check if a function of a given name exists.(futharkThe return type is polymorphic, so there is no guarantee it actually matches the /, but at least we have to use it consistently.(futharkCreate a typed variable from a name and a dynamic type. Note that there is no guarantee that the dynamic type corresponds to the inferred static type, but the latter will at least have to be used consistently.(futhark.Convert a typed variable to a size (a SubExp).(futhark9Convert a typed variable to a similarly typed expression.(futhark;Extract the underlying variable name from a typed variable.(futhark Generate a , prefixed with ( if it exists.(futhark Generate a , prefixed with ( if it exists.)futharkGet the current symbol table.)futharkRun an action with a modified symbol table. All changes to the symbol table will be reverted once the action is done!)futharkIn the case of a histogram-like accumulator, also sets the index parameters.)futhark-Is this copy really a mapping with transpose?)futharkCopy from here to there; both destination and source be indexeded. If so, they better be arrays of enough dimensions. This function will generally just Do What I Mean, and Do The Right Thing. Both destination and source must be in scope.)futharkAs ), but implicitly es the indexes.)futharkcompileAlloc pat size space allocates n bytes of memory in space, writing the result to dest, which must be a single /,)futharkThe number of bytes needed to represent the array in a straightforward contiguous format, as an  expression.)futharkIs this indexing in-bounds for an array of the given shape? This is useful for things like scatter, which ignores out-of-bounds writes.)futhark>Declare an array in row-major order in the given memory block.)futharkLike ), but permute the in-memory representation of the indices as specified.)futhark Uses linear/iota index function.)futhark Uses linear/iota index function.)futharkUntyped assignment.)futharkTyped assignment.)futharkConstructing an ad-hoc function that does not correspond to any of the IR functions in the input program.)futharkdIndexSpace f dims i: computes a list of indices into an array with dimension dims given the flat index i2. The resulting list will have the same size as dims'. Intermediate results are passed to f.)futharkLike ), but invent some new names for the indexes based on the given template.((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))(((((((((((((((((((((((((((((((())())((((((((((((((((())))(((((((((()(((((((()))))))))(((((((((()))))))))))))))))))))))()3)3None? )futhark Compile a ' program to sequential imperative code.())(None !)futhark>Compile the program to sequential C with a JavaScript wrapper.))None !)futhark$Compile the program to sequential C. ) )None& )futharkThe mechanism that will be used for performing the atomic update. Approximates how efficient it will be. Ordered from most to least efficient.)futharkCan be done by efficient swaps.)futharkRequires explicit locking.)futhark+Locking strategy used for an atomic update.)futharkArray containing the lock.)futhark'Value for us to consider the lock free.)futharkWhat to write when we lock it.)futhark What to write when we unlock it.)futharkA transformation from the logical lock index to the physical position in the array. This can also be used to make the lock array smaller.)futhark7Information about the locks available for accumulators.)futharkIs there an atomic  corresponding to this ?)futhark7Arrays for storing group results shared between threads)futharkTry to extract invariant allocations. If we assume that the given  is the body of a , then it is always safe to move the immediate allocations to the prebody."))))))))))))))))))))))))))))))))))"))))))))))))))))))))))))))))))))))None&))None'A)futhark$Generate code for a SegRed construct)futharkLike )), but where the body is a monadic action.))))None'g))None'))None?'())(None ($)futhark9Compile the program to ImpCode with multicore operations.))))))))None ())None?2)futharkIs there an atomic  corresponding to this ?)futharkThe mechanism that will be used for performing the atomic update. Approximates how efficient it will be. Ordered from most to least efficient.)futhark Supported directly by primitive.)futharkCan be done by efficient swaps.)futharkRequires explicit locking.)futharkA function for generating code for an atomic update. Assumes that the bucket is in-bounds.)futhark+Locking strategy used for an atomic update.)futharkArray containing the lock.)futhark'Value for us to consider the lock free.)futharkWhat to write when we lock it.)futhark What to write when we unlock it.)futharkA transformation from the logical lock index to the physical position in the array. This can also be used to make the lock array smaller.*futharkA mapping from dimensions of nested SegOps to already computed local thread IDs.*futhark7Information about the locks available for accumulators.*futharkWhich target are we ultimately generating code for? While most of the kernels code is the same, there are some cases where we generate special code based on the ultimate low-level API we are targeting.*futharkAssign iterations of a for-loop to all threads in the kernel. The passed-in function is invoked with the (symbolic) iteration. / will be in effect in the body. For multidimensional loops, use *.*futharkAssign iterations of a for-loop to threads in the workgroup. The passed-in function is invoked with the (symbolic) iteration. For multidimensional loops, use *.*futharkIterate collectively though a multidimensional space, such that all threads in the group participate. The passed-in function is invoked with a (symbolic) point in the index space.*futhark>Do an atomic update corresponding to a binary operator lambda.*futharkFor many kernels, we may not have enough physical groups to cover the logical iteration space. Some groups thus have to perform double duty; we put an outer loop to accomplish this. The advantage over just launching a bazillion threads is that the cost of memory expansion should be proportional to the number of *physical* threads (hardware parallelism), not the amount of application parallelism.*futhark"Perform a Replicate with a kernel.*futharkPerform an Iota with a kernel.)))))))))))))))*))))))))****************************************))*))))))))****************************************)))))))))))))None?4 *futharkCompile < instance to host-level code with calls to various kernels.**None?4*futharkCompile  instance to host-level code with calls to a single-pass kernel.**None5*futharkCompile < instance to host-level code with calls to various kernels.**None?6*futharkCode generation for the body of the SegRed, taking a continuation for saving the results of the body. The results should be represented as a pairing of a ) along with a list of indexes into that  for reading the result.*futharkCompile < instance to host-level code with calls to various kernels.*futharkLike *), but where the body is a monadic action.******None?76*futharkCompile  instance code.**None ?7*futhark=Generate code for a segmented histogram called from the host.**None-?8*futhark Compile a  program to low-level parallel code, with either CUDA or OpenCL characteristics.*futhark Compile a  program to low-level parallel code, with either CUDA or OpenCL characteristics.(****(None9+*futhark3Compile the program to ImpCode with OpenCL kernels.(**(None ?9*futhark.Compile the program to C with calls to OpenCL. * *None:!*futhark1Compile the program to ImpCode with CUDA kernels.(**(None :*futhark,Compile the program to C with calls to CUDA. * * Safe-Inferred://////00 Trustworthy >?D,!*futharkMonads that support type checking. The reason we have this internal interface is because we use distinct monads for checking expressions and declarations.*futhark$The type checker runs in this monad.*futhark!A mapping from import strings to &s. This is used to resolve import declarations.*futhark0Information about an error during type checking.*futharkA collection of 0s.*futharkA single note.*futharkAttach a reference to documentation explaining the error in more detail.*futharkAn unexpected functor appeared!*futhark#An unknown variable was referenced.*futharkAn unknown type was referenced.*futhark,A name prefixed with an underscore was used.*futharkRun a * computation.*futharkRetrieve the current &.*futhark$The name of the current file/import.*futharkAre we type-checking at the top level, or are we inside a nested module?*futhark4We are now going to type-check the body of a module.*futharkLook up a module type.*futharkLook up an import.*futhark Evaluate a *! computation within an extended (not replaced) environment.*futharkElaborate the given name in the given namespace at the given location, producing the corresponding unique .*futharkMap source-level names do fresh unique internal names, and evaluate a type checker context with the mapping active.*futharkTry to prepend qualifiers to the type names such that they represent how to access the type in some scope.*futharkTurn a . * into an actual error.*futharkAll signed integer types.*futharkAll unsigned integer types.*futharkAll integer types.*futharkAll floating-point types.*futharkAll number types.*futharkAll primitive types.*futharkThe &( corresponding to the intrinsics module.*futhark8The names that are available in the initial environment.*futharkConstruct the name of a new type variable given a base description and a tag number (note that this is distinct from actually constructing a VName; the tag here is intended for human consumption but the machine does not care).*futharkType-check an attribute.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&((((**********************************************************************************&&&&&&&&&&&&&*&&&&&&&&&&&&******&&&&*** Safe-Inferred >?L *futharkClass of types which allow for substitution of types with no annotations for type variable names.*futhark!Substitutions to apply in a type.*futharkA type substitution may be a substitution or a yet-unknown substitution (but which is certainly an overloaded primitive type!). The latter is used to remove aliases from types that are yet-unknown but that we know cannot carry aliases (see issue #682).*futharkunifyTypes uf t1 t2 attempts to unify t1 and t2". If unification cannot happen, .> is returned, otherwise a type that combines the aliasing of t1 and t2* is returned. Uniqueness is unified with uf. Assumes sizes already match, and always picks the size of the leftmost type.*futharkx `subtypeOf` y is true if x is a subtype of y (or equal to y ), meaning x is valid whenever y: is. Ignores sizes. Mostly used for checking uniqueness.*futharkx * y is true if x is not less unique than y.*futharkEnsure that the dimensions of the RetType are unique by generating new names for them. This is to avoid name capture.*futharkCheck for duplication of names inside a pattern group. Produces a description of all names used in the pattern group.+futharkcheckTypeParams ps m checks the type parameters ps!, then invokes the continuation m with the checked parameters, while extending the monadic name map with ps.+futharkRetrieve notes describing the purpose or origin of the given ". The location is used as the *current* location, for the purpose of reporting relative locations.+futhark3Replace all type variables with their substitution.+futhark:Replace any top-level type variable with its substitution.+futhark/Instantiate existential context in return type.+futharkUnifies two types.+futharkexpect super sub checks that sub is a subtype of super.+futhark?Assert that this type must be one of the given primitive types.+futhark,Assert that this type must support equality.+futhark)Assert that this type must be zero-order.+futhark8Assert that this type must be valid as an array element.+futharkIn mustHaveConstr usage c t fs , the type t must have a constructor named c that takes arguments of types ts.+futharkAssert that some type must have a field with this name and type.+futharkLike unification, but creates new size variables where mismatches occur. Returns the new dimensions thus created.+futharkPerform a unification of two types outside a monadic context. The type parameters are allowed to be instantiated; all other types are considered rigid.8++++++++++++++++++++++++++++++++++++++++++++++++++++++++8++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Trustworthy>?[+futharkMonomorphise a list of top-level declarations. A module-free input program is expected, so only value declarations and type declaration are accepted.++None \3+futharkConvert a program in source Futhark to a program in the Futhark core language.++ Trustworthy 5>?f+futharkThe state is a set of constraints and a counter for generating type names. This is distinct from the usual counter we use for generating unique names, as these will be user-visible.+futharkMapping function arguments encountered to the sizes they ended up generating (when they could not be substituted directly). This happens for function arguments that are not constants or names.+futharkA description of where an artificial compiler-generated intermediate name came from.+futhark-Name is the result of a function application.+futharkWhat was the source of some existential size? This is used for using the same existential variable if the same source is encountered in multiple locations.+futhark=Type checking happens with access to this environment. The + will be extended during type-checking as bindings come into scope.,futhark4Aliases in parameters indicate the lexical closure.,futhark2Whether something is a global or a local variable.,futharkThe consumption set is a Maybe so we can distinguish whether a consumption took place, but the variable went out of scope since, or no consumption at all took place.,futharkGet the type of an expression, with top level type variables substituted. Never call $; directly (except in a few carefully inspected locations)!,futharkGet the type of an expression, with all type variables substituted. Slower than ,', but sometimes necessary. Never call $; directly (except in a few carefully inspected locations)!,futhark?i,futhark"A loop that has been type-checked.,futharkAn un-checked loop.,futhark Type-check a loop expression, passing in a function for type-checking subexpressions.,,,,,, Safe-Inferred 5>?kj,futharkType-check a single expression in isolation. This expression may turn out to be polymorphic, in which case the list of type parameters will be non-empty.,futharkType-check a top-level (or module-level) function definition. Despite the name, this is also used for checking constant definitions, by treating them as 0-ary functions.,,,, Safe-Inferred mo,futharkCreate unique renames for the module type. This is used for e.g. generative functor application.,futhark,Refine the given type name in the given env.,futharkReturn new renamed/abstracted env, as well as a mapping from names in the signature to names in the new env. This is used for functor application. The first env is the module env, and the second the env it must match.,futhark)Apply a parametric module to an argument.,,,,,,,, Safe-Inferred ?r,futharkType check a program containing no type information, yielding either a type error or a program with complete type information. Accepts a mapping from file names (excluding extension) to previously type checked results. The & is used to resolve relative imports.,futharkType check a single expression containing no type information, yielding either a type error or the same expression annotated with type information. Also returns a list of type parameters, which will be nonempty if the expression is polymorphic. See also ,.,futharkType check a single declaration containing no type information, yielding either a type error or the same declaration annotated with type information along the Env produced by that declaration. See also ,.,futharkType check a single module expression containing no type information, yielding either a type error or the same expression annotated with type information along the Env produced by that declaration. See also ,.,futharkAn initial environment for the type checker, containing intrinsics and such.(*,,,,,,,,,*(, Safe-Inferred ?uo-futharkPre-typechecked imports, including a starting point for the name source.-futhark'Files that should be implicitly opened.-futharkA basis that contains no imports, and has a properly initialised name source.-futharkRead (and parse) all source files (including the builtin prelude) corresponding to a set of root files.-futhark'Read and type-check some Futhark files.-futhark(Read and type-check Futhark imports (no .fut extension; may refer to baked-in prelude). This is an exotic operation that probably only makes sense in an interactive environment.-futharkExtra functions that should be marked as entry points; only applies to the immediate files, not any imports imported.futharkThe files to read.&&&&&&(------------&&&&&&(------None ?yO-futhark'Print a compiler error to stdout. The  controls to which degree auxiliary information (e.g. the failing program) is also printed.-futharkRead a program from the given ., run the given , and finish up with the given .-futharkRead a program from the given ., run the given , and return it.-futhark=Read and type-check a Futhark program, including all imports.-futharkRead and parse (but do not type-check) a Futhark program, including all imports.-futhark-Not verbose, and terminates process on error.-futhark-Not verbose, and terminates process on error.-futharkRun an operation that produces warnings, and handle them appropriately, yielding the non-warning return value. "Proper handling" means e.g. to print them to the screen, as directed by the compiler configuration.%&&&&&&(-------------------------Nonez-futharkThe version of Futhark that we are using. This is equivalent to the version defined in the .cabal file.-futhark/The version of Futhark that we are using, as a ..----None|v-futharkA command line option that either purely updates a configuration, or performs an IO action (and stops).-futharkGenerate a main action that parses the given command line options (while always adding -).-futharkCommon definitions for -v and -h', given the list of all other options.-futharkTerminate the program with this error message (but don't report it as an ICE, as happens with /).0000000000000--------None--futhark,Are we compiling a library or an executable?-futhark2An option that modifies the configuration of type cfg.-futhark,Run a parameterised Futhark compiler, where cfg6 is a user-given configuration type. Call this from main.-futharkInitial configuration.futhark&Options that affect the configuration.futhark,The short action name (e.g. "compile to C").futharkThe longer action description.futharkThe pipeline to use.futhark1The action to take on the result of the pipeline.futhark Program namefutharkCommand line arguments.&&&&&&(-----------------------------None -futharkThe class generated by the code generator must have a constructor, although it can be vacuous.-futhark0Unpack the array being passed to an entry point.-futhark>Construct the Python array being returned from an entry point.-futhark;Create a static array of values - initialised at load time.-futhark&Copy from one memory block to another.-futharkAllocate a memory block of the given size in the given memory space, saving a reference in the given variable name.-futharkRead a scalar from the given memory block with the given index and in the given memory space.-futharkWrite a scalar to the given memory block with the given index and in the given memory space.-futharkA substitute expression compiler, tried before the main compilation function.-futharkA set of operations that fail for every operation involving non-default memory spaces. Uses plain pointers and malloc for memory management.-futhark7A constructor that takes no arguments and does nothing.-futharkA  where the function is a variable and every argument is a simple .-futhark#The ctypes type corresponding to a .-futhark#The ctypes type corresponding to a , taking sign into account.-futhark"The Numpy type corresponding to a .-futhark"The Numpy type corresponding to a , taking sign into account.-futharkConvert from scalar to storage representation for the given type.-futharkConvert from storage to scalar representation for the given type.-futharkTell me how to compile a v, and I'll Compile any  PrimExp v for you.7-------------------------------------------------------7-------------------------------------------------------None-futharkCompile the program to Python.--None v-futhark*Python code (as a string) that calls the initiatialize_opencl_object5 procedure. Should be put in the class constructor.--None?-futhark3Compile the program to Python with calls to OpenCL.--None ?*-futharkRun  futhark test.--None ?w-futharkRun  futhark run.--None-futharkRun  futhark query.--None  -futharkRun  futhark pkg.--None?-futhark futhark imports-futhark  futhark hash-futhark futhark dataget------None ?-futharkRun futhark literate.--None 0.futharkRun futhark dataset...None y.futharkRun futhark datacmp..None.futharkRun  futhark check...None ?.futharkRun  futhark bench...None ?[.futharkRun futhark autotune..None .futhark%renderFiles important_imports imports; produces HTML files documenting the type-checked program imports, with the files in important_imports considered most important. The HTML files must be written to the specific locations indicated in the return value, or the relative links will be wrong...None .futharkRun  futhark doc...None ?g.futharkRun  futhark repl...None ?.futharkPrint the result to stdout..futhark.Print the result to stdout, alias annotations..futharkPrint call graph to stdout..futhark.Print metrics about AST node counts to stdout..futharkConvert the program to sequential ImpCode and print it to stdout..futhark:Convert the program to GPU ImpCode and print it to stdout..futharkConvert the program to CPU multicore ImpCode and print it to stdout..futharkThe  futhark c action..futharkThe futhark opencl action..futharkThe  futhark cuda action..futharkThe futhark multicore action..futharkThe futhark python action..futharkThe futhark pyopencl action..futharkThe  futhark wasm action..futharkThe futhark wasm-multicore action...............................None?F.futharkRun  futhark c..None?.futharkRun  futhark py..None?.futharkRun futhark pyopencl...None? .futharkRun futhark opencl..None?c.futharkRun  futhark c..None?.futharkRun futhark multicore...None?C.futharkEntry point. Non-interactive, except when reading interpreter input from standard input...None?.futharkRun  futhark cuda...None?.futharkRun  futhark c..0                                                                                                                                                                                                                                                                                                                                                                             ! ! ! ! !! ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !! ! !!!!! ! ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !! ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " " " " " " " " " " " " " # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % & & & & & & & & & & & & & & & & & & & & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*****************************************++++++++++++++++++++,-.............................../////////0000000000000000000111111111111111111111111111111111111111111111112222222222222222222223333333333333333333333334444444444444444444444444445555555555555555556666666666666666777888888888888888888999999999999999999999999:::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<======>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAABBBCCCCCCCCCCCCCCCCCCDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFFFFFFFGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIJKLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNOOOOOPPPQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSTT T T T T T T TTTTTTTTTUUUUUUUVWWWXXXXXXYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[ [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^____________________________________________`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbccccccccccccdeeeeeeeeeeeeeeeeeeeeffffffffffffggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiijkkkkkkkllllllllmmmmmmnnnnoooooooooppppppppqqrrrrrrrrrrrrrrsssssssssssssttttttttttuuuvvwwwxxxxxxxyyzzzzzzzzzzzzzz{{{{{{{{|||}}~~~                                                                                                                                                                       !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! !!!! !!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!  !!!!!!!!!!!!!!!!!!!!!!!!!!""""""""   """""""""""""""""""""""""""""""""""""""""""""""""""""""" """""""""""""""""""""""  """"""   """""""""""""""""""""""""""""""""""################################################################ #####  # ###   ############### ##########  ########################## ####$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ %%%   !   %%%%%%%%%%%%%%%%%%%!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&& &&&&&&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%&&&&&&&&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((('''''('''''''((((((((((((((((((('''('''''(((((('(((((((((((''''('''(((((('((((( (((((((((((('((((('((((((((((((((((((((((((((((( (((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))&%%#)))))))))))))))))))))))))))))))))))))))))))))))))))%)))))))))))) ))))))))))******* **************************************************************************************************************** ''************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++$$+++++++++++++++++++++++#,,,,,,,,,,,,,,,,,,,,,,,,,,,!!,,,,,,,,,,,,+,,+,,,,+,+,+,,+,++,,,,,,,,++,++,+,,,,++++,+,,,+,+,,,?,,+,,,+,+,+,+,+,+,+,,,,,,,,,+,+,+,+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+,+,+,+,,,,,+,+,+,+,+,+,+,+,,,,,,,,,,,,,,,,,,,,-,-,-,-,-,,-,,-,,-,,-]-+--,-------------*----------------------------------futhark-0.20.8-inplaceFuthark.IR.PrimitiveLanguage.Futhark.Core Futhark.TestFuthark.Util.PrettyFuthark.Pkg.TypesFuthark.Internalise.MonadLanguage.Futhark.QueryFuthark.Analysis.Metrics.Type*Futhark.CodeGen.Backends.GenericC.Manifest)Futhark.CodeGen.Backends.GenericC.OptionsFuthark.CodeGen.RTS.CFuthark.CodeGen.RTS.JavaScriptFuthark.CodeGen.RTS.Python Futhark.UtilFuthark.IR.Prop.RearrangeFuthark.Util.ConsoleFuthark.Util.IntegralExpFuthark.Util.LogFuthark.Pkg.InfoFuthark.Pkg.SolveFuthark.Test.ValuesFuthark.ScriptFuthark.Test.Spec Futhark.BenchFuthark.IR.Primitive.Parse Futhark.ErrorFuthark.Util.TableFuthark.IR.Syntax.CoreFuthark.IR.Prop.ConstantsFuthark.IR.Prop.TypesFuthark.IR.RetTypeFuthark.IR.RepFuthark.IR.SyntaxFuthark.IR.Prop.ReshapeFuthark.IR.Prop.PatternsFuthark.IR.PrettyFuthark.IR.Prop.ScopeFuthark.IR.TraversalsFuthark.IR.Prop.TypeOfFuthark.IR.Prop.NamesFuthark.Analysis.PrimExpFuthark.Transform.Substitute!Futhark.CodeGen.OpenCL.HeuristicsFuthark.Analysis.PrimExp.Parse#Futhark.Analysis.PrimExp.GeneralizeFuthark.IR.GPU.SizesFuthark.FreshNamesFuthark.MonadFreshNamesFuthark.Transform.RenameFuthark.IR.PropFuthark.IR.Prop.AliasesFuthark.Analysis.UsageTableFuthark.Analysis.RephraseFuthark.Analysis.Metrics!Futhark.Analysis.DataDependencies Futhark.PassFuthark.Builder.ClassFuthark.BuilderFuthark.IR.AliasesFuthark.Optimise.Simplify.RepFuthark.Analysis.AliasFuthark.ConstructFuthark.TypeCheckFuthark.PipelineFuthark.Compiler.Config2Futhark.Optimise.InPlaceLowering.SubstituteIndices Futhark.Analysis.PrimExp.Convert&Futhark.Optimise.Simplify.Rules.SimpleFuthark.IR.Mem.IxFunFuthark.Analysis.SymbolTable%Futhark.Optimise.Simplify.Rules.IndexFuthark.Optimise.Simplify.Rule*Futhark.Optimise.Simplify.Rules.ClosedForm$Futhark.Optimise.Simplify.Rules.Loop'Futhark.Optimise.Simplify.Rules.BasicOpFuthark.Optimise.Simplify.Rules Futhark.Optimise.Simplify.Engine!Futhark.Analysis.PrimExp.SimplifyFuthark.Optimise.SimplifyFuthark.Transform.CopyPropagateFuthark.IR.SeqFuthark.IR.SOACS.SOAC Futhark.ToolsFuthark.IR.SOACS%Futhark.Transform.FirstOrderTransform Futhark.Pass.FirstOrderTransform"Futhark.Pass.ExtractKernels.ISRWIM!Futhark.Internalise.AccurateSizesFuthark.IR.SOACS.SimplifyFuthark.Analysis.CallGraphFuthark.IR.Mem Futhark.Pass.ExplicitAllocationsFuthark.IR.SegOp)Futhark.Pass.ExtractKernels.BlockedKernel(Futhark.Pass.ExtractKernels.Distribution'Futhark.Pass.ExtractKernels.Interchange+Futhark.Pass.ExtractKernels.DistributeNestsFuthark.IR.Mem.SimplifyFuthark.IR.SeqMem$Futhark.Pass.ExplicitAllocations.SeqFuthark.IR.MC.OpFuthark.IR.MCMem Futhark.IR.MCFuthark.IR.GPU.OpFuthark.IR.GPUFuthark.Pass.KernelBabysitting!Futhark.Pass.ExtractKernels.ToGPUFuthark.Pass.ExtractMulticore(Futhark.Pass.ExtractKernels.StreamKernel&Futhark.Pass.ExtractKernels.IntragroupFuthark.Pass.ExtractKernels!Futhark.Optimise.TileLoops.SharedFuthark.Optimise.Sink-Futhark.Optimise.InPlaceLowering.LowerIntoStm Futhark.Optimise.InPlaceLoweringFuthark.Optimise.CSE Futhark.Optimise.InliningDeadFunFuthark.Optimise.BlkRegTilingFuthark.Optimise.TileLoopsFuthark.IR.GPU.SimplifyFuthark.Optimise.UnstreamFuthark.IR.GPUMemFuthark.Pass.Simplify&Futhark.Pass.ExplicitAllocations.SegOp#Futhark.Pass.ExplicitAllocations.MC$Futhark.Pass.ExplicitAllocations.GPUFuthark.Pass.ExpandAllocationsFuthark.Optimise.DoubleBufferFuthark.IR.ParseFuthark.Analysis.LastUseFuthark.Analysis.Interference2Futhark.Optimise.MemoryBlockMerging.GreedyColoring#Futhark.Optimise.MemoryBlockMergingFuthark.Analysis.HORep.SOAC!Futhark.Optimise.Fusion.ComposingFuthark.Analysis.HORep.MapNest"Futhark.Optimise.Fusion.LoopKernelFuthark.Optimise.FusionFuthark.PassesFuthark.CodeGen.ImpCodeFuthark.CodeGen.SetDefaultSpace Futhark.CodeGen.ImpGen.Transpose"Futhark.CodeGen.ImpCode.SequentialFuthark.CodeGen.ImpCode.OpenCL!Futhark.CodeGen.ImpCode.MulticoreFuthark.CodeGen.ImpCode.GPU$Futhark.CodeGen.ImpGen.GPU.Transpose"Futhark.CodeGen.Backends.SimpleRep(Futhark.CodeGen.Backends.GenericC.Server%Futhark.CodeGen.Backends.GenericC.CLI!Futhark.CodeGen.Backends.GenericC#Futhark.CodeGen.ImpGen.GPU.ToOpenCL0Futhark.CodeGen.Backends.SequentialC.Boilerplate$Futhark.CodeGen.Backends.GenericWASM,Futhark.CodeGen.Backends.COpenCL.Boilerplate*Futhark.CodeGen.Backends.CCUDA.Boilerplate*Futhark.CodeGen.Backends.GenericPython.AST.Futhark.CodeGen.Backends.GenericPython.OptionsLanguage.Futhark.PreludeLanguage.Futhark.SyntaxLanguage.Futhark.PropLanguage.Futhark.PrettyLanguage.Futhark.ParserLanguage.FutharkLanguage.Futhark.SemanticLanguage.Futhark.InterpreterFuthark.Internalise.TypesValuesFuthark.Internalise.LambdasFuthark.Internalise.FreeVarsFuthark.Internalise.BindingsFuthark.Internalise.ExpsLanguage.Futhark.TraversalsFuthark.Internalise.LiftLambdas Futhark.Internalise.Defunctorise#Futhark.Internalise.Defunctionalise"Language.Futhark.TypeChecker.MatchLanguage.Futhark.WarningsFuthark.CodeGen.ImpGen!Futhark.CodeGen.ImpGen.Sequential'Futhark.CodeGen.Backends.SequentialWASM$Futhark.CodeGen.Backends.SequentialC%Futhark.CodeGen.ImpGen.Multicore.Base(Futhark.CodeGen.ImpGen.Multicore.SegScan'Futhark.CodeGen.ImpGen.Multicore.SegRed'Futhark.CodeGen.ImpGen.Multicore.SegMap(Futhark.CodeGen.ImpGen.Multicore.SegHist Futhark.CodeGen.ImpGen.Multicore#Futhark.CodeGen.Backends.MulticoreC&Futhark.CodeGen.Backends.MulticoreWASMFuthark.CodeGen.ImpGen.GPU.Base*Futhark.CodeGen.ImpGen.GPU.SegScan.TwoPass-Futhark.CodeGen.ImpGen.GPU.SegScan.SinglePass"Futhark.CodeGen.ImpGen.GPU.SegScan!Futhark.CodeGen.ImpGen.GPU.SegRed!Futhark.CodeGen.ImpGen.GPU.SegMap"Futhark.CodeGen.ImpGen.GPU.SegHistFuthark.CodeGen.ImpGen.GPUFuthark.CodeGen.ImpGen.OpenCL Futhark.CodeGen.Backends.COpenCLFuthark.CodeGen.ImpGen.CUDAFuthark.CodeGen.Backends.CCUDA"Language.Futhark.TypeChecker.Monad"Language.Futhark.TypeChecker.Types"Language.Futhark.TypeChecker.Unify Futhark.Internalise.MonomorphiseFuthark.Internalise(Language.Futhark.TypeChecker.Terms.Monad&Language.Futhark.TypeChecker.Terms.Pat)Language.Futhark.TypeChecker.Terms.DoLoop"Language.Futhark.TypeChecker.Terms$Language.Futhark.TypeChecker.ModulesLanguage.Futhark.TypeCheckerFuthark.Compiler.ProgramFuthark.CompilerFuthark.VersionFuthark.Util.OptionsFuthark.Compiler.CLI&Futhark.CodeGen.Backends.GenericPython)Futhark.CodeGen.Backends.SequentialPython-Futhark.CodeGen.Backends.PyOpenCL.Boilerplate!Futhark.CodeGen.Backends.PyOpenCLFuthark.CLI.TestFuthark.CLI.RunFuthark.CLI.QueryFuthark.CLI.PkgFuthark.CLI.MiscFuthark.CLI.LiterateFuthark.CLI.DatasetFuthark.CLI.DatacmpFuthark.CLI.CheckFuthark.CLI.BenchFuthark.CLI.AutotuneFuthark.Doc.GeneratorFuthark.CLI.DocFuthark.CLI.REPLFuthark.ActionsFuthark.CLI.WASMFuthark.CLI.PythonFuthark.CLI.PyOpenCLFuthark.CLI.OpenCLFuthark.CLI.MulticoreWASMFuthark.CLI.MulticoreFuthark.CLI.DevFuthark.CLI.CUDA Futhark.CLI.CData.Traversable mapAccumLFuthark.Util.Loc Futhark.IRLanguage.Futhark.Parser.LexerLanguage.Futhark.Parser.Parser Paths_futharkbaseGHC.IntInt8Int16Int32Int64GHC.WordWord8Word16Word32Word64futhark-data-1.0.3.0-30ca59ac13a60b8450ff9ee098ddcaa05bce0cb6acfcb5751a8da4af73004ed6Futhark.Data.Compare compareValuesMismatch Futhark.Data valueTextValuehalf-0.3.1-3f0e04aa34cd7da8061416bcdf9362fc6bb68a8570f84f7114e3430332c8543cNumeric.Half.InternalHalfsrcloc-0.6-241806dc41d1d6ec25e40bb23ee9295d5d38126623f5516cffb76e7346f844adData.LoclocOfmainland-pretty-0.7.1-be6e399aec3d9d0788dac035d59623339a42059818d4f3c51b23fe729a5db9d4Text.PrettyPrint.Mainland hPutDocLnhPutDocputDocLnputDocprettyPragmaLazyTextdisplayPragmaLazyTextprettyLazyTextdisplayLazyText prettyPragma prettyPragmaSdisplayPragmaS prettyCompactprettyCompactSprettySdisplayS renderCompactrendererrordocfaildoc fillbreakfillwidthnestingcolumnnestindenthangalignlisttuple enclosesepsemisepcommasep punctuatesepcatstackspreadfolddocparensIfparensbracketsbraces backquotesanglesdquotessquotesencloseflattengroup<|><+/><+> softbreaksoftlinelinesrclocemptyrparenlparenrbracketlbracketrbracelbraceranglelangledquotesquote backquotespacesspacesemiequalsdotcommacolonstarlazyText strictTextrationaldoublefloatintegerintstringcharbooltextDocRLineRPos RLazyTextRTextRStringRCharREmptyRDocmegaparsec-9.2.0-6d24a7d9f6252967bd3f4941b62ade1312d4f864455beafaaf464bafb7343873Text.Megaparsec.ErrorerrorBundlePretty mtl-2.2.2Control.Monad.Error.Class throwErrorsrclocOfPosLocSrcLoc locOfListLocatedversions-5.0.0-7561471a8de9af947d92c7089950ddf01c15d7f7591abef2143e7f012ebda374 Data.Versions prettySemVer_svMeta _svPreRel_svPatch_svMinor_svMajorSemVerStrDigitsVUnit AstMetrics$fReadAstMetrics$fShowAstMetricsManifestmanifestEntryPoints manifestTypesmanifestBackendType TypeArray TypeOpaque OpaqueOps opaqueFree opaqueStore opaqueRestoreArrayOps arrayFree arrayShape arrayValuesarrayNew EntryPointentryPointCFunentryPointOutputsentryPointInputsOutput outputType outputUniqueInput inputName inputType inputUniquemanifestToJSON$fToJSONArrayOps$fToJSONOpaqueOps$fToJSONManifest $fEqManifest $fOrdManifest$fShowManifest$fEqType $fOrdType $fShowType $fEqOpaqueOps$fOrdOpaqueOps$fShowOpaqueOps $fEqArrayOps $fOrdArrayOps$fShowArrayOps$fEqEntryPoint$fOrdEntryPoint$fShowEntryPoint $fEqOutput $fOrdOutput $fShowOutput $fEqInput $fOrdInput $fShowInputOptionArgument NoArgumentRequiredArgumentOptionalArgumentOptionoptionLongNameoptionShortNameoptionArgumentoptionDescription optionActiongenerateOptionParseratomicsH chaselevHcudaH freeListHhalfHlockHopenclH scalarF16HscalarH schedulerHserverHtimingHtuningHutilHvaluesHserverJsvaluesJswrapperclassesJsmemoryPyopenclPypanicPyscalarPyserverPytuningPyvaluesPy BuildList unBuildList PkgManifestmanifestPkgPathmanifestRequiremanifestEndCommentsRequired requiredPkgrequiredPkgRev requiredHash Commentedcomments commentedComment PkgRevDepsPkgPathpkgPathFilePathisCommitVersion commitVersion parseVersion futharkPkgnewPkgManifestprettyPkgManifest pkgRevDepspkgDiraddRequiredToManifestremoveRequiredFromManifestparsePkgManifestparsePkgManifestFromFileprettyBuildList$fMonoidPkgRevDeps$fSemigroupPkgRevDeps$fTraversableCommented$fFoldableCommented$fFunctorCommented $fEqBuildList$fShowBuildList$fShowPkgManifest$fEqPkgManifest$fShowRequired $fEqRequired$fShowCommented $fEqCommented$fShowPkgRevDeps EncodedString UserStringnubOrdnubByOrd mapAccumLMchunkchunksmaxinumdropAttakeLastdropLast mapEithermaybeNth maybeHead splitFromEndsplitAt3focusNthhashTextunixEnvironmentisEnvVarAtLeast fancyTerminalrunProgramWithExitCodedirectoryContents roundFloat ceilFloat floorFloat roundDouble ceilDouble floorDoublelgammalgammaftgammatgammafhypothypotftoPOSIX fromPOSIXtrimpmapIOreadFileSafely convFloat zEncodeString atMostChars invertMaprearrangeShaperearrangeInverserearrangeReachrearrangeComposeisPermutationOftransposeIndexisMapTransposecolorinRedinBoldWrapped wrappedValue IntegralExpquotremdivmodsgndivUp$fIntegralExpWrapped $fNumWrapped $fEqWrapped $fOrdWrapped $fShowWrapped MonadLoggerlogMsgaddLogToLogtoLogLogtoText $fMonoidLog$fSemigroupLog $fToLogText $fToLog[]$fMonadLoggerRWST$fMonadLoggerRWST0$fMonadLoggerWriterTMonadPkgRegistrygetPkgRegistryputPkgRegistrymodifyPkgRegistry PkgRegistryPkgInfo pkgVersionspkgLookupCommit PkgRevInfopkgRevZipballUrlpkgRevZipballDir pkgRevCommitpkgRevGetManifest pkgRevTime GetManifest getManifestdownloadZipball lookupPkgRevpkgInfo lookupPackagelookupPackageRevlookupNewestRev$fEqGetManifest$fShowGetManifest$fMonoidPkgRegistry$fSemigroupPkgRegistry$fEqPkgRevInfo$fShowPkgRevInfo PkgRevDepInfo solveDeps solveDepsPure$fFunctorPkgOp$fShowRoughBuildListpretty prettyTextprettyTextOneLine prettyOneLine prettyDoc prettyTupleprettyTupleLinesapplyoneLinetextwrapannot nestedBlockshorten commastack $fPrettyHalf CompoundValueCompound ValueRecord ValueTuple ValueAtom mkCompound unCompound$fPrettyValueType $fPrettyValue$fPrettyCompound$fTraversableCompound$fFoldableCompound$fFunctorCompound $fEqCompound $fOrdCompound$fShowCompound EvalBuiltinExpValueValOrVarVValVVarScriptValueTypeSTValueSTFun ScriptValueSValueSFunExpCallConstTupleRecord StringLitLet ServerVarFuncFuncFut FuncBuiltin ScriptServerwithScriptServer'withScriptServerparseExpparseExpFromTextscriptValueTypeserverVarsInValue valueToExpevalExp getExpValueevalExpToGround varsInExp freeValue $fPrettyFunc $fPrettyExp$fTraversableScriptValue$fFoldableScriptValue$fFunctorScriptValue$fPrettyScriptValueType$fShowValOrVar$fEqScriptValueType$fShowScriptValueType$fShowScriptValue $fShowExp $fShowFuncSuccess SuccessValuesSuccessGenerateValuesExpectedResultSucceedsRunTimeFailureGenValueGenPrimValuesInFile GenValues ScriptValues ScriptFileTestRunrunTagsrunInputrunExpectedResultrunIndexrunDescription WarningTestExpectedWarning StructureTestStructurePipeline GpuPipeline SOACSPipelineSeqMemPipelineGpuMemPipeline NoPipeline ExpectedErrorAnyError ThisError InputOutputs iosEntryPoint iosTestRuns TestActionCompileTimeFailureRunCases ProgramTesttestDescriptiontestTags testAction genValueTypetestSpecFromProgramtestSpecFromProgramOrDietestSpecsFromPathstestSpecsFromPathsOrDietestSpecFromFiletestSpecFromFileOrDie$fShowExpectedError$fShowWarningTest$fShowProgramTest$fShowTestAction$fShowInputOutputs $fShowTestRun $fShowSuccess$fShowExpectedResult $fShowValues$fShowGenValue$fShowStructureTest$fShowStructurePipeline FutharkExevaluesFromByteString getValues getValuesBS valuesAsVarstestRunReferenceOutputgetExpectedResult binaryNamecompileProgram runProgram readResultsensureReferenceOutputdetermineTuning checkResultfutharkServerCfg$fEqFutharkExe$fOrdFutharkExe$fShowFutharkExeCompileOptions compFuthark compBackend compOptions RunOptionsrunRuns runTimeout runVerboserunResultAction BenchResult DataResultResult runResults memoryMapstdErr RunResultrunMicrosecondsencodeBenchResultsdecodeBenchResultsbenchmarkDatasetprepareBenchmarkProgram$fFromJSONRunResult$fToJSONRunResult$fFromJSONResult$fToJSONResult$fFromJSONDataResults$fToJSONDataResults$fFromJSONBenchResults$fToJSONBenchResults$fEqBenchResult$fShowBenchResult$fEqDataResult$fShowDataResult $fEqResult $fShowResult $fEqRunResult$fShowRunResultConvOpZExtSExtFPConvFPToUIFPToSIUIToFPSIToFPIToBBToICmpOpCmpEqCmpUltCmpUleCmpSltCmpSleFCmpLtFCmpLeCmpLltCmpLleBinOpAddFAddSubFSubMulFMulUDivUDivUpSDivSDivUpFDivFModUModSModSQuotSRemSMinUMinFMinSMaxUMaxFMaxShlLShrAShrAndOrXorPowFPowLogAndLogOrSafetyUnsafeSafeOverflow OverflowWrap OverflowUndefUnOpNot ComplementAbsFAbsSSignumUSignumFSignum PrimValueIntValue FloatValue BoolValue UnitValue Float16Value Float32Value Float64Value Int8Value Int16Value Int32Value Int64ValuePrimTypeIntType FloatTypeBoolUnitFloat16Float32Float64 allIntTypes allFloatTypes allPrimTypesintValue intValueType valueIntegral floatValuefloatValueType primValueTypeblankPrimValueallUnOps allBinOps allCmpOps allConvOpsdoUnOp doComplementdoAbsdoFAbs doSSignum doUSignumdoBinOpdoAdddoMuldoSDivdoSModdoPowdoConvOp flipConvOpdoZExtdoSExtdoFPConvdoFPToUIdoFPToSIdoUIToFPdoSIToFPdoCmpOpdoCmpEqdoCmpUltdoCmpUledoCmpSltdoCmpSledoFCmpLtdoFCmpLe intToWord64 intToInt64 binOpType cmpOpTypeunOpType convOpTypeprimFunszeroIshoneIsh negativeIsh zeroIshInt oneIshInt primBitSize primByteSize intByteSize floatByteSizecommutativeBinOp convOpFun prettySigned$fPrettyIntType$fPrettyFloatType$fPrettyPrimType$fBoundedPrimType$fEnumPrimType$fPrettyIntValue$fPrettyFloatValue$fOrdFloatValue$fEqFloatValue$fPrettyPrimValue $fPrettyUnOp $fOrdOverflow $fEqOverflow $fPrettyBinOp $fPrettyCmpOp$fPrettyConvOp $fEqConvOp $fOrdConvOp $fShowConvOp $fEqCmpOp $fOrdCmpOp $fShowCmpOp $fEqBinOp $fOrdBinOp $fShowBinOp $fEqSafety $fOrdSafety $fShowSafety$fShowOverflow$fEqUnOp $fOrdUnOp $fShowUnOp $fEqPrimValue$fOrdPrimValue$fShowPrimValue$fShowFloatValue $fEqIntValue $fOrdIntValue$fShowIntValue $fEqPrimType $fOrdPrimType$fShowPrimType $fEqFloatType$fOrdFloatType$fShowFloatType$fEnumFloatType$fBoundedFloatType $fEqIntType $fOrdIntType $fShowIntType $fEnumIntType$fBoundedIntType constituent whitespacelexemekeyword pPrimValue pFloatTypepIntType pPrimType InternalErrorError CompilerError ExternalError ErrorClass CompilerBugCompilerLimitation externalErrorexternalErrorSinternalErrorS compilerBugcompilerLimitation compilerBugScompilerLimitationS$fShowCompilerError$fExceptionInternalError$fShowInternalError$fEqErrorClass$fOrdErrorClass$fShowErrorClassEntrymkEntry buildTable$fShowRowTemplateVNameName Uniqueness NonuniqueUniquedefaultEntryPoint nameToStringnameFromString nameToText nameFromTextlocStr locStrRelprettyStacktracebaseTagbaseName baseStringquotepquote$fPrettyUniqueness$fMonoidUniqueness$fSemigroupUniqueness $fPrettyName $fOrdVName $fEqVName $fShowVName $fShowName$fEqName $fOrdName$fIsStringName$fSemigroupName$fEqUniqueness$fOrdUniqueness$fShowUniquenessAttrsunAttrsAttrAttrNameAttrIntAttrComp ErrorMsgPart ErrorStringErrorValErrorMsgPatElemTPatElem patElemName patElemDec FlatSlice FlatDimIndexSliceunSliceDimIndexDimFixDimSliceParam paramAttrs paramNameparamDecSubExpConstantVarCertsunCertsIdent identName identTypeDietConsumeObserve ObservePrim DeclExtTypeDeclTypeExtTypeTypeBasePrimAccArrayMem NoUniquenessSpaceIdSpace DefaultSpace ScalarSpace ArrayShape shapeRank stripDims subShapeOfRankExtShapeExtSizeExtFreeShape ShapeBase shapeDims CommutativityNoncommutative CommutativedimFix sliceIndices sliceDims unitSlicefixSlice sliceSlice flatSliceDimsflatSliceStrideserrorMsgArgTypesoneAttrinAttrs withoutAttrs$fMonoidCommutativity$fSemigroupCommutativity$fMonoidShapeBase$fSemigroupShapeBase$fTraversableShapeBase$fFoldableShapeBase$fFunctorShapeBase$fTraversableExt $fFoldableExt $fFunctorExt $fMonoidRank$fSemigroupRank$fArrayShapeRank$fMonoidNoUniqueness$fSemigroupNoUniqueness $fMonoidCerts$fSemigroupCerts$fArrayShapeShapeBase$fArrayShapeShapeBase0$fBifoldableTypeBase$fBifunctorTypeBase$fBitraversableTypeBase $fOrdIdent $fEqIdent$fTraversableDimIndex$fFoldableDimIndex$fFunctorDimIndex$fFoldableSlice$fFunctorSlice$fTraversableSlice$fFoldableFlatDimIndex$fFunctorFlatDimIndex$fTraversableFlatDimIndex$fFoldableFlatSlice$fFunctorFlatSlice$fTraversableFlatSlice$fTraversablePatElemT$fFoldablePatElemT$fFunctorPatElemT$fTraversableErrorMsgPart$fFoldableErrorMsgPart$fFunctorErrorMsgPart$fIsStringErrorMsgPart$fTraversableErrorMsg$fFoldableErrorMsg$fFunctorErrorMsg$fIsStringErrorMsg$fIsStringAttr$fTraversableParam$fFunctorParam$fFoldableParam $fOrdParam $fShowParam $fEqParam $fOrdAttrs $fShowAttrs $fEqAttrs $fMonoidAttrs$fSemigroupAttrs $fOrdAttr $fShowAttr$fEqAttr $fEqErrorMsg $fOrdErrorMsg$fShowErrorMsg$fEqErrorMsgPart$fOrdErrorMsgPart$fShowErrorMsgPart $fOrdPatElemT$fShowPatElemT $fEqPatElemT $fEqFlatSlice$fOrdFlatSlice$fShowFlatSlice$fEqFlatDimIndex$fOrdFlatDimIndex$fShowFlatDimIndex $fEqSlice $fOrdSlice $fShowSlice $fEqDimIndex $fOrdDimIndex$fShowDimIndex $fShowIdent$fShowTypeBase $fEqTypeBase $fOrdTypeBase $fShowSpace $fEqSpace $fOrdSpace $fShowSubExp $fEqSubExp $fOrdSubExp $fEqCerts $fOrdCerts $fShowCerts$fEqDiet $fOrdDiet $fShowDiet$fEqNoUniqueness$fOrdNoUniqueness$fShowNoUniqueness $fShowRank$fEqRank $fOrdRank$fEqExt$fOrdExt $fShowExt $fEqShapeBase$fOrdShapeBase$fShowShapeBase$fEqCommutativity$fOrdCommutativity$fShowCommutativityIsValuevalueconstantintConst floatConst$fIsValueFloatValue$fIsValueIntValue$fIsValuePrimValue $fIsValueBool$fIsValueFloat$fIsValueDouble$fIsValueWord64$fIsValueWord32$fIsValueWord16$fIsValueWord8$fIsValueInt64$fIsValueInt32$fIsValueInt16 $fIsValueInt8FixExtfixExtSetTypesetType DeclExtTyped declExtTypeOfExtTyped extTypeOf DeclTyped declTypeOfTypedtypeOf rankShaped arrayRank setArrayShape existential uniquenessunique staticShapes staticShapes1arrayOf arrayOfRow arrayOfShape setArrayDims setOuterSize setDimSize setOuterDimsetDim peelArray stripArray shapeSize arrayDims arrayExtDims arraySize arraysSizerowTypeprimTypeelemType transposeType rearrangeType mapOnExtType mapOnTypediet subtypeOf subtypesOftoDeclfromDeclisExtisFreeextractShapeContext shapeContexthasStaticShapegeneraliseExtTypesexistentialiseExtTypesshapeExtMappingint8int16int32int64float32float64 $fTyped(,)$fTypedPatElemT $fTypedParam $fTypedIdent$fTypedTypeBase$fTypedTypeBase0$fDeclTypedParam$fDeclTypedTypeBase$fSetTypePatElemT $fSetType(,)$fSetTypeTypeBase $fFixExt() $fFixExtExt $fFixExt[]$fFixExtShapeBase$fFixExtTypeBase$fDeclExtTypedTypeBase$fExtTypedTypeBase IsRetType primRetType applyRetType IsBodyType primBodyType expectedTypes$fIsBodyTypeTypeBase$fIsRetTypeTypeBaseRepTypesLetDecExpDecBodyDec FParamInfo LParamInfoRetType BranchTypeOpProg progConstsprogFuns EntryParamentryParamNameentryParamTypeEntryPointType TypeUnsigned TypeDirectFunDeffunDefEntryPoint funDefAttrs funDefName funDefRetType funDefParams funDefBodyLParamFParamLambdaLambdaT lambdaParams lambdaBodylambdaReturnTypeIfSortIfNormal IfFallbackIfEquivIfDec ifReturnsifSortLoopFormForLoop WhileLoopExpTBasicOpApplyIfDoLoopWithAcc WithAccInputOpaqueArrayLitAssertIndexUpdate FlatIndex FlatUpdateConcatCopyIota ReplicateScratchReshape RearrangeRotate UpdateAccOpaqueOp OpaqueNil OpaqueTrace ShapeChange DimChange DimCoercionDimNewBodyBodyTbodyDecbodyStms bodyResult SubExpResresCerts resSubExpStmsStmstmPatstmAuxstmExpStmAux stmAuxCerts stmAuxAttrs stmAuxDecPatPatTpatElemsoneStm stmsFromList stmsToListstmsHead subExpResvarRes subExpsResvarsRes$fTraversablePatT$fFoldablePatT $fFunctorPatT $fMonoidPatT$fSemigroupPatT$fSemigroupStmAux$fTraversableDimChange$fFoldableDimChange$fFunctorDimChange $fEqDimChange$fEqProg $fOrdProg $fShowProg$fEqEntryParam$fShowEntryParam$fOrdEntryParam$fEqEntryPointType$fShowEntryPointType$fOrdEntryPointType $fEqIfDec $fShowIfDec $fOrdIfDec $fEqIfSort $fShowIfSort $fOrdIfSort $fEqBasicOp $fOrdBasicOp $fShowBasicOp $fEqOpaqueOp $fOrdOpaqueOp$fShowOpaqueOp$fOrdDimChange$fShowDimChange $fEqSubExpRes$fOrdSubExpRes$fShowSubExpRes $fOrdStmAux $fShowStmAux $fEqStmAux $fOrdPatT $fShowPatT$fEqPatT $fOrdFunDef $fShowFunDef $fEqFunDef $fOrdLambdaT $fShowLambdaT $fEqLambdaT $fOrdLoopForm$fShowLoopForm $fEqLoopForm $fOrdExpT $fShowExpT$fEqExpT $fEqBodyT $fShowBodyT $fOrdBodyT$fEqStm $fShowStm$fOrdStmnewDimnewDimsnewShape shapeCoerce reshapeOuter reshapeInner shapeCoercion fuseReshape informReshape reshapeIndexunflattenIndex flattenIndex sliceSizes paramType paramDeclType paramIdent patElemIdent patElemType setPatElemDec patIdentspatNamespatTypespatSizebasicPat PrettyRepppExpDecppTuple'$fPrettyDimIndex$fPrettyDimChange$fPrettyEntryParam$fPrettyEntryPointType$fPrettyErrorMsg$fPrettyBasicOp$fPrettyFlatSlice$fPrettyFlatDimIndex $fPrettySlice $fPrettyParam$fPrettyPatElemT $fPrettyPatT $fPrettyAttrs $fPrettyAttr$fPrettySubExpRes $fPrettyCerts$fPrettySubExp $fPrettyIdent$fPrettyTypeBase$fPrettyTypeBase0$fPrettyTypeBase1 $fPrettySpace$fPrettyShapeBase $fPrettyExt$fPrettyShapeBase0$fPrettyNoUniqueness$fPrettyCommutativity $fPrettyVName $fPrettyProg$fPrettyFunDef$fPrettyLambdaT $fPrettyExpT $fPrettyStm $fPrettyBodyT $fPrettySeq ExtendedScope SameScopeScopedscopeOf LocalScope localScopeHasScope lookupType lookupInfoaskScope asksScopeScopeNameInfoLetName FParamName LParamName IndexName inScopeOf scopeOfPatscopeOfPatElemscopeOfLParamsscopeOfFParams castScope extendedScope$fTypedNameInfo$fHasScoperepRWST$fHasScoperepRWST0$fHasScoperepExceptT$fHasScoperepReaderT$fLocalScoperepRWST$fLocalScoperepRWST0$fLocalScoperepReaderT$fLocalScoperepExceptT$fScopedrepLambdaT$fScopedrepLoopForm$fScopedrep(,)$fScopedrepFunDef$fScopedrepStm$fScopedrepSeq $fScopedrep[]$fHasScoperepExtendedScope$fFunctorExtendedScope$fApplicativeExtendedScope$fMonadExtendedScope$fMonadReaderMapExtendedScope$fShowNameInfoTraverseOpStmstraverseOpStmsOpStmsTraverserWalker walkOnSubExp walkOnBody walkOnVName walkOnRetTypewalkOnBranchType walkOnFParam walkOnLParamwalkOnOpMapper mapOnSubExp mapOnBody mapOnVName mapOnRetTypemapOnBranchType mapOnFParam mapOnLParammapOnOpidentityMappermapExpMmapExpidentityWalkerwalkExpMtraverseLambdaStmsTypedOpopType subExpType subExpResTypemapType basicOpType expExtTypeexpExtTypeSize$fHasScoperepFeelBad$fApplicativeFeelBad$fFunctorFeelBad $fTypedOp()FreeDec precomputedFreeInfreeIn'FVNames namesIntMapnameIn namesFromList namesToListoneNamenamesIntersectionnamesIntersect namesSubtractmapNamesfvBindfvNamefvNamesfreeInStmsAndResfreeIn boundInBody boundByStm boundByStms boundByLambda $fPrettyNames $fMonoidNames$fSemigroupNames $fOrdNames $fSemigroupFV $fMonoidFV $fFreeInIfDec$fFreeInStmAux $fFreeInAttrs $fFreeInCerts $fFreeInPatT$fFreeInSubExpRes$fFreeInFlatSlice$fFreeInFlatDimIndex $fFreeInSlice$fFreeInDimIndex$fFreeInDimChange$fFreeInLoopForm$fFreeInPatElemT $fFreeInParam$fFreeInTypeBase$fFreeInPrimType $fFreeInExt$fFreeInShapeBase $fFreeInSpace$fFreeInSubExp $fFreeInIdent $fFreeInVName $fFreeInMaybe $fFreeInBool $fFreeInNames $fFreeInSeq $fFreeIn[] $fFreeIn(,,,) $fFreeIn(,,) $fFreeIn(,) $fFreeInInt $fFreeIn() $fFreeInFV$fFreeDecNames$fFreeDecMaybe $fFreeDec[] $fFreeDec(,) $fFreeDec() $fFreeInStm $fFreeInExpT $fFreeInBodyT$fFreeInLambdaT$fFreeInFunDef $fEqNames $fShowNamesFloatExp fromRational'IntExpNumExp fromInteger' fromBoolExpTPrimExpuntypedPrimExpLeafExpValueExpBinOpExpCmpOpExpUnOpExp ConvOpExpFunExpisInt8isInt16isInt32isInt64isBoolisF16isF32isF64primExpSizeAtLeastconstFoldPrimExp.&&..||..<..<=..==..>..>=..&..|..^..>>..<<.sExtzExt evalPrimExp primExpTypecoerceIntPrimExptruefalsebNotsMax32sMin32sMax64sMin64sExt32sExt64zExt32zExt64fMin64fMax64 leafExpTypes$fPrettyPrimExp$fFreeInPrimExp$fTraversablePrimExp$fFoldablePrimExp$fFunctorPrimExp$fPrettyTPrimExp$fFloatingTPrimExp$fFloatingTPrimExp0$fFloatingTPrimExp1$fFreeInTPrimExp$fTraversableTPrimExp$fFoldableTPrimExp$fFunctorTPrimExp $fNumTPrimExp$fNumExpDouble $fNumExpFloat $fNumExpHalf $fNumExpInt64 $fNumExpInt32 $fNumExpInt16 $fNumExpInt8$fIntegralExpTPrimExp $fIntExpInt64 $fIntExpInt32 $fIntExpInt16 $fIntExpInt8$fFractionalTPrimExp$fFloatExpDouble$fFloatExpFloat$fFloatExpHalf $fEqTPrimExp $fOrdTPrimExp$fShowTPrimExp $fEqPrimExp $fOrdPrimExp $fShowPrimExp Substitutable SubstitutesubstituteNames Substitutions$fSubstituteFV$fSubstituteTPrimExp$fSubstitutePrimExp$fSubstituteFlatSlice$fSubstituteFlatDimIndex$fSubstituteSlice$fSubstituteDimIndex$fSubstituteDimChange$fSubstituteIdent$fSubstituteTypeBase$fSubstitutePrimType$fSubstituteNames$fSubstituteExt$fSubstituteShapeBase$fSubstitute()$fSubstituteRank$fSubstituteCerts$fSubstitutePatT$fSubstituteSubExpRes$fSubstituteParam$fSubstituteStmAux$fSubstituteAttrs$fSubstitutePatElemT$fSubstituteSubExp$fSubstituteVName$fSubstituteBool$fSubstituteMaybe$fSubstitute(,,,)$fSubstitute(,,)$fSubstitute(,)$fSubstituteSeq$fSubstitute[]$fSubstituteNameInfo$fSubstituteLambdaT$fSubstituteBodyT$fSubstituteStm$fSubstituteExpT SizeHeuristic platformName deviceType heuristicSizeheuristicValue WhichSize LockstepWidth NumGroups GroupSizeTileSize RegTileSize Threshold DeviceInfo DeviceType DeviceCPU DeviceGPUsizeHeuristicsTable$fPrettyDeviceInfopPrimExpleastGeneralGeneralization NumThreadsCountunCount SizeClass SizeThreshold SizeGroup SizeNumGroupsSizeTile SizeRegTileSizeLocalMemory SizeBespoke KernelPath sizeDefault$fPrettySizeClass$fTraversableCount$fFoldableCount$fFunctorCount $fEqCount $fOrdCount $fShowCount $fNumCount$fIntegralExpCount $fFreeInCount $fPrettyCount$fSubstituteCount $fEqSizeClass$fOrdSizeClass$fShowSizeClass VNameSourcenewNameblankNameSource newNameSource$fMonoidVNameSource$fSemigroupVNameSource$fLiftLiftedRepVNameSource$fEqVNameSource$fOrdVNameSourceMonadFreshNames getNameSource putNameSourcemodifyNameSourcenewNameFromStringnewVNamenewIdent newIdent'newParam$fMonadFreshNamesExceptT$fMonadFreshNamesMaybeT$fMonadFreshNamesWriterT$fMonadFreshNamesWriterT0$fMonadFreshNamesReaderT$fMonadFreshNamesRWST$fMonadFreshNamesRWST0$fMonadFreshNamesStateT$fMonadFreshNamesStateT0 RenameableRenamerenameRenameM renameProg renameExp renameStm renameBody renameLambda renamePatrenameSomethingsubstituteRename renameBound renamingStms$fRenameDimIndex $fRename() $fRenameExt$fRenameShapeBase $fRenameRank $fRenameNames$fRenameTypeBase$fRenamePrimType$fRenameSubExpRes$fRenameStmAux $fRenameAttrs $fRenameCerts$fRenamePatElemT $fRenamePatT $fRenameParam$fRenameSubExp $fRenameIdent $fRenameBool $fRenameMaybe $fRename(,,) $fRename(,) $fRename[] $fRenameVName$fRenameLambdaT $fRenameExpT $fRenameStm $fRenameBodyT$fRenameFunDef$fFunctorRenameM$fApplicativeRenameM$fMonadRenameM$fMonadFreshNamesRenameM$fMonadReaderRenameEnvRenameMASTRepexpTypesFromPatIsOpsafeOpcheapOpASTConstraintsisBuiltInFunctionbuiltInFunctions asBasicOpsafeExp subExpVars subExpVarcommutativeLambdaentryPointSizedefAuxstmCertscertifyexpExtTypesFromPatattrsForAssert lamIsBinOp$fIsOp() CanBeAliased OpWithAliasesremoveOpAliases addOpAliases AliasTable AliasedOp opAliases consumedInOp AliasesOf aliasesOfAliased bodyAliasesconsumedInBody subExpAliases expAliases consumedInStm consumedInExpconsumedByLambda patAliases lookupAliases$fAliasesOfPatElemT$fAliasesOfNames $fAliasedOp()$fCanBeAliased()Usages UsageTablewithoutlookupusedexpand isConsumed isInResultisUsedDirectlyisSizeusagesusage consumedUsage inResultUsage sizeUsage sizeUsages consumedU usageInStm$fMonoidUsages$fSemigroupUsages$fMonoidUsageTable$fSemigroupUsageTable$fEqUsageTable$fShowUsageTable $fEqUsages $fOrdUsages $fShowUsages RephraserrephraseExpDecrephraseLetBoundDecrephraseFParamDecrephraseLParamDecrephraseBodyDecrephraseRetTyperephraseBranchType rephraseOp rephraseProgrephraseFunDef rephraseExp rephraseStm rephrasePatrephrasePatElem rephraseBodyrephraseLambdaMetricsM OpMetrics opMetricsseeninside progMetrics stmMetrics lambdaMetrics$fMonoidCountMetrics$fSemigroupCountMetrics $fOpMetrics()$fOpMetricsMaybe$fMonadMetricsM$fApplicativeMetricsM$fFunctorMetricsM!$fMonadWriterCountMetricsMetricsM DependenciesdataDependenciesfindNecessaryForReturnedPasspassNamepassDescription passFunctionPassMrunPassM liftEither liftEitherMpassLongOptionparPass'intraproceduralTransformationWithConstsintraproceduralTransformation$fMonadFreshNamesPassM$fMonadLoggerPassM$fFunctorPassM$fApplicativePassM $fMonadPassM MonadBuilderRep mkExpDecMmkBodyM mkLetNamesMaddStmaddStms collectStms certifying BuildablemkExpPatmkExpDecmkBody mkLetNames attributingauxingletBindmkLetmkLet' letBindNames collectStms_bodyBind insertStms insertStmBuilderBuilderT BuilderOps mkExpDecBmkBodyB mkLetNamesB runBuilderT runBuilderT_ runBuilderT' runBuilderT'_ runBuilder runBuilder_runBodyBuilder$fMonadErroreBuilderT$fMonadWriterwBuilderT$fMonadStatesBuilderT$fMonadReaderrBuilderT$fMonadBuilderBuilderT$fLocalScoperepBuilderT$fHasScoperepBuilderT$fMonadFreshNamesBuilderT$fMonadTransBuilderT$fFunctorBuilderT$fMonadBuilderT$fApplicativeBuilderTAliasesAndConsumed BodyAliasing ConsumedInExp VarAliasesAliasDec unAliasesAliasesremoveScopeAliasesremoveProgAliasesremoveFunDefAliasesremoveExpAliasesremoveStmAliasesremoveLambdaAliasesremovePatAliasesaddAliasesToPat mkAliasedBody mkPatAliases mkBodyAliases mkStmsAliases trackAliasesmkAliasedLetStm$fBuilderOpsAliases$fASTRepAliases$fBuildableAliases$fPrettyRepAliases$fAliasedAliases$fFreeDecAliasDec$fPrettyAliasDec$fFreeInAliasDec$fSubstituteAliasDec$fRenameAliasDec $fOrdAliasDec $fEqAliasDec$fMonoidAliasDec$fSemigroupAliasDec$fAliasesOf(,)$fRepTypesAliases$fShowAliasDec CanBeWise OpWithWisdomremoveOpWisdom addOpWisdom Informing ExpWisdom VarWisdomvarWisdomAliasesWiseremoveScopeWisdomaddScopeWisdomremoveFunDefWisdomremoveStmWisdomremoveLambdaWisdomremoveBodyWisdomremoveExpWisdomremovePatWisdomaddWisdomToPat mkWiseBody mkWiseLetStm mkWiseExpDec informStms informLambda informFunDef$fPrettyVarWisdom$fFreeInVarWisdom$fSubstituteVarWisdom$fRenameVarWisdom$fRenameExpWisdom$fSubstituteExpWisdom$fFreeDecExpWisdom$fFreeInExpWisdom$fFreeDecBodyWisdom$fFreeInBodyWisdom$fSubstituteBodyWisdom$fRenameBodyWisdom $fCanBeWise()$fBuildableWise $fAliasedWise$fPrettyRepWise $fASTRepWise$fRepTypesWise$fEqBodyWisdom$fOrdBodyWisdom$fShowBodyWisdom $fEqExpWisdom$fOrdExpWisdom$fShowExpWisdom $fEqVarWisdom$fOrdVarWisdom$fShowVarWisdom aliasAnalysis analyseFun analyseBody analyseStms analyseExp analyseLambdaToExptoExp letSubExpletExp letInPlace letSubExps letTupExp letTupExp'eSubExpeParameIfeIf'eBinOpeCmpOpeConvOpeSignumeCopyeBodyeLambdaeRoundToMultipleOf eSliceArray eOutOfBoundseBlankasIntSasIntZ foldBinOpeAll binOpLambda cmpOpLambdamkLambdasliceDim fullSlicesliceAt fullSliceNum isFullSliceifCommon resultBody resultBodyM insertStmsM buildBody buildBody_ mapResultinstantiateShapesinstantiateShapes'removeExistentialssimpleMkLetNamestoSubExp $fToExpVName $fToExpSubExp Checkable checkExpDec checkBodyDeccheckFParamDeccheckLParamDeccheckLetBoundDec checkRetTypematchPat primFParammatchReturnTypematchBranchTypematchLoopResult CheckableOpcheckOpTypeM TypeError ErrorCaseUnexpectedTypeReturnTypeErrorDupDefinitionError DupParamError DupPatErrorInvalidPatErrorUnknownVariableErrorUnknownFunctionErrorParameterMismatch SlicingError BadAnnotation ReturnAliasedUniqueReturnAliased NotAnArrayPermutationErrorbadcontextmessageconsume checkOpWith alternativeconsumeOnlyParamsbinding lookupVarrequirerequireI checkProg checkSubExp checkCerts checkStms checkBodycheckExpcheckSOACArrayArgs checkType checkExtTypecheckStm matchExtPatmatchExtBranchTypeargType argAliases noArgAliasescheckArg checkLambdarequirePrimExp$fMonoidConsumption$fSemigroupConsumption$fHasScopeAliasesTypeM$fShowTypeError$fShowErrorCase $fMonadTypeM$fFunctorTypeM$fApplicativeTypeM$fMonadReaderEnvTypeM$fMonadStateTStateTypeM$fShowConsumption $fEqOccurence$fShowOccurence $fEqUsage $fOrdUsage $fShowUsagePipelinePipelineConfigpipelineVerbosepipelineValidateAction actionNameactionDescriptionactionProcedureFutharkM Verbosity NotVerboseVerbose VeryVerbose runFutharkM runPipelineonePasspasses$fMonadLoggerFutharkM$fMonadFreshNamesFutharkM$fCategoryTYPEPipeline$fApplicativeFutharkM$fFunctorFutharkM$fMonadFutharkM!$fMonadErrorCompilerErrorFutharkM $fMonadStateFutharkStateFutharkM$fMonadReaderFutharkEnvFutharkM$fMonadIOFutharkM $fEqVerbosity$fOrdVerbosity FutharkConfigfutharkVerbose futharkWarn futharkWerror futharkSafefutharkEntryPointsfutharkTypeChecknewFutharkConfigIndexSubstitutionsIndexSubstitutionsubstituteIndicesprimExpFromExpprimExpFromSubExpMprimExpFromSubExppe32le32pe64le64f32pef32lef64pef64lereplaceInPrimExpMreplaceInPrimExpsubstituteInPrimExp primExpSlice subExpSlice$fToExpTPrimExp$fToExpPrimExp TypeLookup VarLookupapplySimpleRulesIxFun ixfunLMADs ixfunContigLMAD lmadOffsetlmadDimsLMADDimldStrideldRotateldShapeldPermldMon MonotonicityIncDecUnknownsubstituteInIxFunisDirectshapeindex iotaOffsetiotapermuterotateslice flatSlicereshaperankrebaselinearWithOffsetrearrangeWithOffsetisLinearexistentialize closeEnough equivalent$fPrettyMonotonicity$fTraversableLMAD$fFoldableLMAD $fFunctorLMAD $fFreeInLMAD $fRenameLMAD$fSubstituteLMAD $fPrettyLMAD$fTraversableIxFun$fFoldableIxFun$fFunctorIxFun $fFreeInIxFun $fRenameIxFun$fSubstituteIxFun $fPrettyIxFun $fShowIxFun $fEqIxFun $fShowLMAD$fEqLMAD $fShowLMADDim $fEqLMADDim$fShowMonotonicity$fEqMonotonicityIndexOpindexOp entryDepth entryIsSize entryAccInputIndexed IndexedArray SymbolTable loopDepthbindingsavailableAtClosestLoopsimplifyMemory fromScopetoScopedeepenindexedAddCertsentryStm entryFParam entryLParamentryLetBoundDecelem lookupStm lookupExp lookupBasicOp lookupSubExp lookupLoopVarlookupLoopParam availableindex' insertFParams insertLParaminsertLoopMerge insertLoopVar hideCertified noteAccTokens$fFreeInIndexed $fTypedEntry$fMonoidSymbolTable$fSemigroupSymbolTable $fIndexOp() IndexResult SubExpResultsimplifyIndexingRuleBook BottomUpRuleBottomUpRuleOpBottomUpRuleDoLoopBottomUpRuleIfBottomUpRuleBasicOpBottomUpRuleGenericBottomUp TopDownRule TopDownRuleOpTopDownRuleDoLoop TopDownRuleIfTopDownRuleBasicOpTopDownRuleGenericTopDownSimplificationRule RuleGeneric RuleBasicOpRuleIf RuleDoLoopRuleOpRuleSimplifySkipRuleMcannotSimplify liftMayberuleBooktopDownSimplifyStmbottomUpSimplifyStm$fMonadBuilderRuleM $fMonoidRules$fSemigroupRules$fMonoidRuleBook$fSemigroupRuleBook$fFunctorRuleM$fApplicativeRuleM $fMonadRuleM$fMonadFreshNamesRuleM$fHasScoperepRuleM$fLocalScoperepRuleMfoldClosedFormloopClosedForm loopRules basicOpRules standardRulesremoveUnnecessaryCopy SimplifiablesimplifySimplifiableRep BlockPredSimpleM SimpleOps mkExpDecSmkBodySprotectHoistedOpSopUsageS simplifyOpS SimplifyOpEnvenvRulesenvHoistBlockers HoistBlockers blockHoistPar blockHoistSeqblockHoistBranch isAllocationnoExtraHoistBlockers neverHoistemptyEnvbindableSimpleOps runSimpleM asksEngineEnv askVtable localVtable enterLoop bindLParams hoistStms neverBlocksisFalseorIfisOpblockIfhasFree isNotSafe simplifyBody simplifyStmssimplifyStmsWithUsagesimplifyLambdasimplifyLambdaNoHoisting simplifyFun$fMonadFreshNamesSimpleM$fSimplifiableCerts$fSimplifiableSlice$fSimplifiableDimIndex$fSimplifiableTypeBase$fSimplifiablePrimType$fSimplifiableSpace$fSimplifiableExt$fSimplifiableShapeBase$fSimplifiableVName$fSimplifiable()$fSimplifiableSubExpRes$fSimplifiableSubExp$fSimplifiable[]$fSimplifiableMaybe$fSimplifiableInt$fSimplifiable(,,)$fSimplifiable(,)$fLocalScopeWiseSimpleM$fHasScopeWiseSimpleM$fApplicativeSimpleM$fFunctorSimpleM$fMonadSimpleM$fMonadReader(,)SimpleM$fMonadState(,,)SimpleMsimplifyPrimExpsimplifyExtPrimExp simplifyProgsimplifySomethingcopyPropagateInProgcopyPropagateInStmscopyPropagateInFunSeq$fTraverseOpStmsWise$fBuilderOpsWise$fPrettyRepSeq$fTraverseOpStmsSeq$fBuilderOpsSeq$fBuildableSeq$fCheckableSeq$fCheckableOpSeq $fASTRepSeq $fRepTypesSeq SOACMappermapOnSOACSubExpmapOnSOACLambdamapOnSOACVNameReduceredComm redLambda redNeutralScan scanLambda scanNeutral ScremaForm StreamFormParallel Sequential StreamOrdInOrderDisorderHistOp histWidthhistRaceFactorhistDest histNeutralhistOpSOACStreamScatterHistScrema scanResults singleScan redResults singleReduce scremaTypemkIdentityLambdaisIdentityLambdanilFn scanomapSOAC redomapSOACscanSOAC reduceSOACmapSOACisScanomapSOAC isScanSOAC isRedomapSOAC isReduceSOAC isMapSOAC scremaLambdagroupScatterResultsgroupScatterResults'splitScatterResultsidentitySOACMappermapSOACMtraverseSOACStmssoacType typeCheckSOACppScremappHist $fPrettyScan$fPrettyReduce $fPrettySOAC$fOpMetricsSOAC $fIndexOpSOAC $fIsOpSOAC$fAliasedOpSOAC $fTypedOpSOAC$fCanBeWiseSOAC$fCanBeAliasedSOAC $fRenameSOAC$fSubstituteSOAC $fFreeInSOAC$fEqSOAC $fOrdSOAC $fShowSOAC$fEqScremaForm$fOrdScremaForm$fShowScremaForm $fEqReduce $fOrdReduce $fShowReduce$fEqScan $fOrdScan $fShowScan$fEqStreamForm$fOrdStreamForm$fShowStreamForm $fEqStreamOrd$fOrdStreamOrd$fShowStreamOrd $fEqHistOp $fOrdHistOp $fShowHistOpredomapToMapAndReduce dissectScremasequentialStreamWholeArraypartitionChunkedFoldParametersSOACS$fPrettyRepSOACS$fBuilderOpsSOACS$fBuildableSOACS$fCheckableSOACS$fCheckableOpSOACS $fASTRepSOACS$fRepTypesSOACS Transformer FirstOrderReptransformFunDeftransformConststransformStmRecursively transformSOACtransformLambdafirstOrderTransformiswimirwim rwimPossible InternaliseMInternaliseEnv envSubstsenvDoBoundsChecksenvSafeenvAttrs VarSubstsFunInforunInternaliseMsubstitutingVars lookupSubst addFunDeflookupFunction'lookupFunction lookupConst bindFunction bindConstantlocalConstsScopeassert$fMonadBuilderInternaliseM$fFunctorInternaliseM$fApplicativeInternaliseM$fMonadInternaliseM'$fMonadReaderInternaliseEnvInternaliseM($fMonadStateInternaliseStateInternaliseM$fMonadFreshNamesInternaliseM$fHasScopeSOACSInternaliseM$fLocalScopeSOACSInternaliseM argShapesensureResultShapeensureResultExtShapeensureExtShape ensureShapeensureArgShapesHasSOACasSOACsoacOp simpleSOACS simplifySOACSsimplifyConsts simplifySOAC soacRulesliftIdentityMappingremoveReplicateMappingsimplifyKnownIterationSOACsimplifyMapIota $fHasSOACWise $fEqArrayOp $fOrdArrayOp $fShowArrayOp CallGraphisFunInCallGraphcallscalledByConsts allCalledBybuildCallGraph numOccurencesfindNoninlined$fPrettyFunCalls$fSemigroupFunCalls$fMonoidFunCalls$fPrettyCallGraph $fEqCallGraph$fOrdCallGraph$fShowCallGraph $fEqFunCalls $fOrdFunCalls$fShowFunCalls OpReturns opReturns FunReturns BodyReturns ExpReturns MemReturnReturnsInBlockReturnsNewBlockMemBindArrayInMemBoundMemInfoMemPrimMemMemMemArrayMemAccExtIxFunMemOpAllocInner HasLetDecMem letDecMem BranchTypeMem RetTypeMem LParamMem FParamMem LetDecMemtraverseMemOpStms isStaticIxFunexistentialiseIxFunnoUniquenessReturnsbodyReturnsToExpReturnsmatchFunctionReturnTypematchLoopResultMemmatchBranchReturnType matchPatToExp lookupMemInfo subExpMemInfolookupArraySummary checkMemInfobodyReturnsFromPat extReturns varReturns expReturns$fIndexOpMemOp$fCanBeWiseMemOp $fIsOpMemOp$fOpMetricsMemOp $fPrettyMemOp$fSubstituteMemOp $fRenameMemOp$fCanBeAliasedMemOp$fAliasedOpMemOp$fTypedOpMemOp $fFreeInMemOp$fPrettyMemInfo$fSimplifiableMemInfo$fRenameMemInfo$fSubstituteMemInfo$fFreeInMemInfo$fDeclTypedMemInfo$fTypedMemInfo$fTypedMemInfo0$fFixExtMemInfo$fExtTypedMemInfo$fDeclExtTypedMemInfo$fSimplifiableMemBind$fFreeInMemBind$fPrettyMemBind$fSubstituteMemBind$fRenameMemBind $fOrdMemBind $fEqMemBind$fHasLetDecMem(,)$fHasLetDecMemMemInfo$fSimplifiableMemReturn$fFreeInMemReturn$fPrettyMemReturn$fFixExtMemReturn$fSubstituteMemReturn$fRenameMemReturn$fOrdMemReturn $fEqMemReturn$fIsBodyTypeMemInfo$fIsRetTypeMemInfo $fOpReturns()$fOpReturnsMemOp$fShowMemReturn $fShowMemBind $fEqMemInfo $fShowMemInfo $fOrdMemInfo $fEqMemOp $fOrdMemOp $fShowMemOpExpHintNoHintHint SizeSubst opSizeSubst opIsConstAllocMAllocEnvchunkMapaggressiveReuse allocSpace envConsts allocInOp envExpHintsChunkMap AllocabledimAllocationSizearraySizeInBytesExp allocForArrayexplicitAllocationsGeneric explicitAllocationsInStmsGeneric allocInStms mkLetNamesB' mkLetNamesB'' simplifiabledefaultExpHints$fSizeSubstMemOp $fSizeSubst()$fMonadBuilderAllocM$fApplicativeAllocM$fFunctorAllocM $fMonadAllocM$fMonadFreshNamesAllocM$fHasScopetorepAllocM$fLocalScopetorepAllocM$fMonadReaderAllocEnvAllocMHasSegOp SegOpLevelasSegOpsegOp SegOpMappermapOnSegOpSubExpmapOnSegOpLambdamapOnSegOpBodymapOnSegOpVNamemapOnSegOpLevelSegOpSegMapSegRedSegScanSegHistSegSpacesegFlat unSegSpaceSegVirt SegNoVirt SegNoVirtFull KernelResultReturns WriteReturns ConcatReturns TileReturnsRegTileReturnsResultManifestResultNoSimplifyResultMaySimplify ResultPrivate KernelBody kernelBodyDeckernelBodyStmskernelBodyResultSegBinOp segBinOpCommsegBinOpLambdasegBinOpNeutral segBinOpShape histShape SplitOrderingSplitContiguous SplitStridedhistTypesegBinOpResultssegBinOpChunkskernelResultCertskernelResultSubExpaliasAnalyseKernelBodyconsumedInKernelBody segSpaceDimsscopeOfSegSpacesegLevelsegSpacesegBodytypeCheckSegOpidentitySegOpMapper mapSegOpMtraverseSegOpStms simplifySegOp segOpRules segOpReturns$fSimplifiableSplitOrdering$fRenameSplitOrdering$fSubstituteSplitOrdering$fFreeInSplitOrdering$fPrettySegBinOp$fSimplifiableKernelResult$fPrettyKernelResult$fRenameKernelResult$fSubstituteKernelResult$fFreeInKernelResult$fPrettyKernelBody$fRenameKernelBody$fSubstituteKernelBody$fFreeInKernelBody$fSimplifiableSegSpace$fPrettySegSpace $fIsOpSegOp$fIndexOpSegOp $fPrettySegOp$fOpMetricsSegOp$fAliasedOpSegOp$fTypedOpSegOp$fCanBeWiseSegOp$fCanBeAliasedSegOp $fFreeInSegOp $fRenameSegOp$fSubstituteSegOp $fEqSegOp $fOrdSegOp $fShowSegOp $fEqSegSpace $fOrdSegSpace$fShowSegSpace $fEqSegVirt $fOrdSegVirt $fShowSegVirt$fEqKernelResult$fShowKernelResult$fOrdKernelResult$fEqResultManifest$fShowResultManifest$fOrdResultManifest $fEqSegBinOp $fOrdSegBinOp$fShowSegBinOp$fEqSplitOrdering$fOrdSplitOrdering$fShowSplitOrdering$fEqKernelBody$fShowKernelBody$fOrdKernelBody KernelInputkernelInputNamekernelInputTypekernelInputArraykernelInputIndices MkSegLevelThreadRecommendation ManyThreadsNoRecommendationDistRep mkSegSpacesegRedsegScansegMapdummyDim nonSegRedsegHist mapKernelreadKernelInput$fShowKernelInput KernelNestNestingsNestingnestingLetBound nestingLoop LoopNesting MapNestingloopNestingPatloopNestingAuxloopNestingWidthloopNestingParamsAndArrsTargetsTarget ppTargets singleTarget outerTarget innerTargetpushInnerTargetpopInnerTarget targetsScopescopeOfLoopNesting ppLoopNesting ppNestings singleNestingpushInnerNestingletBindInInnerNesting ppKernelNestinnermostKernelNestingpushKernelNestingpushInnerKernelNesting newKernelkernelNestLoopsscopeOfKernelNestboundInKernelNestboundInKernelNestskernelNestWidthsconstructKernel flatKernel tryDistributetryDistributeStm$fFreeInLoopNesting $fShowNesting$fShowLoopNesting WithAccStmBranchSeqLoopinterchangeLoopsinterchangeBranchinterchangeWithAcc DistNestTDistAcc distTargetsdistStmsDistEnvdistNest distScopedistOnTopLevelStmsdistOnInnerMapdistOnSOACSStmsdistOnSOACSLambda distSegLevelMapLoop mapLoopStm addStmsToAcc addStmToAcc liftInner runDistNestT addPostStmspostStm inNestingbodyContainsParallelismlambdaContainsParallelismdistributeMapBodyStms distributedistributeSingleStm histKerneldetermineReduceOppermutationAndMissing distributeMap$fMonoidPostStms$fSemigroupPostStms$fMonoidDistRes$fSemigroupDistRes$fMonadLoggerDistNestT$fLocalScoperepDistNestT$fHasScoperepDistNestT$fMonadFreshNamesDistNestT$fFunctorDistNestT$fApplicativeDistNestT$fMonadDistNestT$fMonadReaderDistEnvDistNestT$fMonadWriterDistResDistNestTSimplifyMemory simpleGenericsimplifyProgGenericsimplifyStmsGenericSeqMem simpleSeqMem$fTraverseOpStmsSeqMem$fBuilderOpsSeqMem$fCheckableSeqMem$fCheckableOpSeqMem$fPrettyRepSeqMem$fASTRepSeqMem$fRepTypesSeqMemexplicitAllocationsMCOpParOpOtherOptraverseMCOpStms typeCheckMCOp simplifyMCOp$fOpMetricsMCOp $fPrettyMCOp $fIndexOpMCOp$fCanBeWiseMCOp$fCanBeAliasedMCOp$fAliasedOpMCOp $fTypedOpMCOp $fIsOpMCOp $fFreeInMCOp $fRenameMCOp$fSubstituteMCOp$fEqMCOp $fOrdMCOp $fShowMCOpMCMem$fBuilderOpsMCMem$fCheckableMCMem$fCheckableOpMCMem$fPrettyRepMCMem$fOpReturnsMCOp$fOpReturnsMCOp0 $fASTRepMCMem$fRepTypesMCMemMC$fHasSegOpWise $fHasSegOpMC $fPrettyRepMC$fBuilderOpsMC $fBuildableMC $fCheckableMC$fCheckableOpMC $fASTRepMC $fRepTypesMCHostOpSizeOp SplitSpaceGetSize GetSizeMax CmpSizeLe CalcNumGroupsSegLevel SegThreadSegGroup segNumGroups segGroupSizesegVirttraverseHostOpStmstypeCheckHostOp$fFreeInSegLevel$fRenameSegLevel$fSubstituteSegLevel$fSimplifiableSegLevel$fPrettySegLevel$fOpMetricsSizeOp$fPrettySizeOp$fFreeInSizeOp$fAliasedOpSizeOp$fTypedOpSizeOp $fIsOpSizeOp$fRenameSizeOp$fSubstituteSizeOp$fOpMetricsHostOp$fPrettyHostOp$fIndexOpHostOp$fCanBeWiseHostOp$fCanBeAliasedHostOp$fFreeInHostOp$fAliasedOpHostOp$fTypedOpHostOp $fIsOpHostOp$fRenameHostOp$fSubstituteHostOp $fEqHostOp $fOrdHostOp $fShowHostOp $fEqSizeOp $fOrdSizeOp $fShowSizeOp $fEqSegLevel $fOrdSegLevel$fShowSegLevelGPU $fHasSegOpGPU$fPrettyRepGPU$fBuilderOpsGPU$fBuildableGPU$fCheckableGPU$fCheckableOpGPU $fASTRepGPU $fRepTypesGPUbabysitKernelsgetSize segThread injectSOACS soacsStmToGPUsoacsLambdaToGPU scopeForSOACs scopeForGPUextractMulticore$fMonadLoggerExtractM$fFunctorExtractM$fApplicativeExtractM$fMonadExtractM$fHasScopeMCExtractM$fLocalScopeMCExtractM$fMonadFreshNamesExtractM streamRed streamMapsegThreadCapped$fEqKernelSize$fOrdKernelSize$fShowKernelSizeintraGroupParallelise$fMonoidIntraAcc$fSemigroupIntraAcc$fMonadLoggerBuilderTextractKernels$fMonadFreshNamesDistribM$fFunctorDistribM$fApplicativeDistribM$fMonadDistribM$fHasScopeGPUDistribM$fLocalScopeGPUDistribM$fMonadStateStateDistribM$fMonadLoggerDistribM VarianceTableTileMsegMap1DsegMap2DsegMap3D segScatter2DisTileableRedomapvarianceInStmssinkGPUsinkMC LowerUpdate DesiredUpdate updateName updateType updateCerts updateSource updateIndices updateValue lowerUpdatelowerUpdateGPU$fFunctorDesiredUpdate$fShowLoopResultSummary$fShowDesiredUpdateinPlaceLoweringGPUinPlaceLoweringSeqinPlaceLoweringMC$fMonoidBottomUp$fSemigroupBottomUp$fHasScopeAliasesForwardingM$fMonadFreshNamesForwardingM$fMonadForwardingM$fApplicativeForwardingM$fFunctorForwardingM$fMonadReaderTopDownForwardingM $fMonadWriterBottomUpForwardingM"$fMonadStateVNameSourceForwardingMCSEInOp performCSEperformCSEOnFunDefperformCSEOnStms $fCSEInOpSOAC$fCSEInOpMemOp$fCSEInOpSegOp $fCSEInOpMCOp$fCSEInOpHostOp $fCSEInOp()inlineAggressivelyinlineConservativelyremoveDeadFunctionsmmBlkRegTiling doRegTiling3D tileLoops$fMonoidPrivStms$fSemigroupPrivStms simplifyGPUsimplifyKernelOp unstreamGPU unstreamMCGPUMem simpleGPUMem$fBuilderOpsGPUMem$fCheckableGPUMem$fCheckableOpGPUMem$fPrettyRepGPUMem$fOpReturnsHostOp$fOpReturnsHostOp0$fASTRepGPUMem$fRepTypesGPUMem simplifySeq simplifyMCsimplifyGPUMemsimplifySeqMem simplifyMCMemallocInKernelBodyallocInBinOpLambda$fSizeSubstSegOp$fSizeSubstMCOpexplicitAllocationsInStms$fSizeSubstHostOpexpandAllocations$fApplicativeOffsetM$fFunctorOffsetM$fMonadOffsetM$fHasScopeGPUMemOffsetM$fLocalScopeGPUMemOffsetM$fMonadError[]OffsetMdoubleBufferGPUdoubleBufferMC$fLocalScoperepDoubleBufferM$fHasScoperepDoubleBufferM$fShowDoubleBuffer$fFunctorDoubleBufferM$fApplicativeDoubleBufferM$fMonadDoubleBufferM$fMonadReaderEnvDoubleBufferM$fMonadFreshNamesDoubleBufferM parseSOACSparseSeq parseSeqMemparseGPU parseGPUMemparseMC parseMCMem LastUseMap analyseProgGraph analyseGPUColoring colorGraphoptimiseNotSOACViewLEmptyL:>ViewFEmptyF:<ArrayTransformsArrayTransform ReshapeOuter ReshapeInner noTransformsnullTransformsviewfviewl|><|transformFromExpvarInput identInput isVarInput isVarishInput addTransformaddInitialTransforms inputArray inputRowType inputRank transformRowstransposeInputinputs setInputslambda setLambdatoSOACfromExp soacToStream$fSubstituteArrayTransform$fSubstituteArrayTransforms$fMonoidArrayTransforms$fSemigroupArrayTransforms $fPrettyInput$fSubstituteInput $fShowNotSOAC$fEqArrayTransforms$fOrdArrayTransforms$fShowArrayTransforms$fShowArrayTransform$fEqArrayTransform$fOrdArrayTransformfuseMaps fuseRedomapmergeReduceOpsMapNestnestingParamNames nestingResultnestingReturnType nestingWidthparamsfromSOAC $fShowMapNest $fEqNesting $fOrdNestingFusedKerfsoacinplace fusedVars fusedConsumed kernelScopeoutputTransformoutNameskerAuxtransformOutput arrInputs attemptFusion$fShowFusedKer$fFunctorTryFusion$fApplicativeTryFusion$fAlternativeTryFusion$fMonadTryFusion$fMonadFailTryFusion$fMonadFreshNamesTryFusion$fHasScopeSOACSTryFusion$fLocalScopeSOACSTryFusion fuseSOACs $fShowError$fMonoidFusedRes$fSemigroupFusedRes$fHasScopeSOACSFusionGM$fMonadFreshNamesFusionGM$fMonadFusionGM$fApplicativeFusionGM$fFunctorFusionGM$fMonadErrorErrorFusionGM$fMonadStateVNameSourceFusionGM$fMonadReaderFusionGEnvFusionGM $fEqKernName $fOrdKernName$fShowKernNamestandardPipelinekernelsPipelinesequentialPipelinesequentialCpuPipeline gpuPipeline mcPipelinemulticorePipelineBytesElementsArgExpArgMemArgTExp VolatilityVolatile NonvolatileCode:>>:ForWhile DeclareMem DeclareScalar DeclareArrayAllocateWrite SetScalarReadSetMem DebugPrint TracePrint ArrayContents ArrayValues ArrayZerosFunction FunctionT functionEntryfunctionOutput functionInput functionBodyfunctionResult functionArgs ExternalValue OpaqueValueTransparentValue ValueDesc ArrayValue ScalarValue Signedness Constants constsDecl constsInit Functions Definitions defConstsdefFunsMemParam ScalarParamDimSizeMemSizelexicalMemoryUsage calledFuncselementsbytes withElemTypevar declaredIn$fFreeInValueDesc$fPrettyValueDesc$fFreeInExternalValue$fPrettyExternalValue$fPrettyArrayContents $fFreeInArg $fPrettyArg $fFreeInCode$fTraversableCode$fFoldableCode $fFunctorCode $fPrettyCode $fMonoidCode$fSemigroupCode$fTraversableFunctionT$fFoldableFunctionT$fFunctorFunctionT$fPrettyFunctionT$fFreeInFunctions$fTraversableFunctions$fFoldableFunctions$fFunctorFunctions$fPrettyFunctions$fMonoidFunctions$fSemigroupFunctions$fPrettyConstants$fFunctorConstants$fPrettyDefinitions$fFunctorDefinitions$fShowDefinitions$fShowConstants$fShowFunctions$fShowFunctionT $fShowCode $fShowArg$fEqVolatility$fOrdVolatility$fShowVolatility$fShowArrayContents$fShowExternalValue $fEqValueDesc$fShowValueDesc$fEqSignedness$fOrdSignedness$fShowSignednesssetDefaultSpacesetDefaultCodeSpace transposeArgsmapTransposeFunctionProgram$fFreeInSequential$fPrettySequential KernelTarget TargetOpenCL TargetCUDAOpenCL LaunchKernel KernelSafety SafetyNone SafetyCheap SafetyFull KernelArg ValueKArgMemKArgSharedMemoryKArg KernelName FailureMsg failureErrorfailureBacktrace openClProgram openClPreludeopenClKernelNamesopenClUsedTypes openClSizesopenClFailureshostDefinitionsnumFailureParams$fPrettyOpenCL$fEqKernelTarget $fShowOpenCL$fEqKernelSafety$fOrdKernelSafety$fShowKernelSafety $fShowMayFail$fShowKernelArg SchedulingDynamicStatic ParallelTask task_codeflatTid SchedulerInfo nsubtasks iterations schedulingAtomicOp AtomicAdd AtomicSub AtomicAndAtomicOr AtomicXor AtomicXchg AtomicCmpXchg MulticoreSegopParLoopAtomic$fFreeInAtomicOp$fPrettyScheduling$fFreeInSchedulerInfo$fPrettySchedulerInfo$fFreeInMulticore$fFreeInParallelTask$fPrettyMulticore$fPrettyParallelTask$fShowAtomicOp AtomicFAdd AtomicSMax AtomicSMin AtomicUMax AtomicUMinKernelOp GetGroupId GetLocalId GetLocalSize GetGlobalSize GetGlobalIdGetLockstepWidthBarrierMemFence LocalAlloc ErrorSyncFence FenceLocal FenceGlobal KernelUse ScalarUse MemoryUseConstUseKernel kernelBody kernelUseskernelNumGroupskernelGroupSize kernelNamekernelFailureTolerant CallKernelKernelConstExp KernelConst SizeConst KernelCode$fPrettyKernelConst$fPrettyKernelUse$fFreeInKernelOp$fPrettyKernelOp$fPrettyKernel$fFreeInKernel $fShowKernel$fShowKernelOp $fShowFence $fEqFence $fOrdFence $fEqKernelUse$fOrdKernelUse$fShowKernelUse$fEqKernelConst$fOrdKernelConst$fShowKernelConst TransposeArgs TransposeTypeTransposeNormalTransposeLowWidthTransposeLowHeightTransposeSmallmapTransposeKernel$fEqTransposeType$fOrdTransposeType$fShowTransposeTypeintTypeToCTypeprimTypeToCTypeprimStorageType primAPIType toStorage fromStorage tupleFieldfunNamedefaultMemBlockType arrayName opaqueName scalarToPrimcproductcsum cScalarDefs storageSizestoreValueHeaderloadValueHeader$fToExpPrimValue$fToExpFloatValue$fToExpIntValue$fToIdentVName $fToIdentText $fToIdentName serverDefscliDefsCPartscHeadercUtilscCLIcServercLib cJsonManifest CompilerM OperationsopsWriteScalar opsReadScalar opsAllocate opsDeallocateopsCopyopsStaticArray opsMemoryType opsCompileropsErroropsCall opsFatMemory opsCritical CallCompiler StaticArray Deallocate ReadScalar WriteScalar MemoryType PointerQuals ErrorCompiler OpCompiler HeaderSection ArrayDecl OpaqueDecl EntryDeclMiscDeclInitDecl CompilerState compNameSrc compUserStatefreeAllocatedMemdefaultOperationscontextContentscontextFinalInits runCompilerM getUserStatemodifyUserStateatInit inNewFunctionitemitems fatMemorycacheMem publicDef publicDef_ headerDecllibDecl earlyDecl contextFieldcontextFieldDyn profileReportonClearstmstmsdecl publicName contextType memToCType rawMemCType fatMemTyperawMemcopyMemoryDefaultSpace asLibrary asExecutableasServer compileProg cachingMemory compileFunwriteScalarPointerWithQualsreadScalarPointerWithQualscompileExpToName compileExpcompilePrimExp compileCode blockScope$fMonadFreshNamesCompilerM$fFunctorCompilerM$fApplicativeCompilerM$fMonadCompilerM"$fMonadStateCompilerStateCompilerM!$fMonadReaderCompilerEnvCompilerM$fEqHeaderSection$fOrdHeaderSection$fEqPublicness$fOrdPublicness$fShowPublicness kernelsToCUDAkernelsToOpenCL $fEqOpsModegenerateBoilerplate JSEntryPointname parametersret extToStringemccExportNamesjavascriptWrapper runServerlibraryExports failureSwitch copyDevToDev copyDevToHost copyHostToDevcopyScalarToDevcopyScalarFromDevprofilingEvent kernelRuntime kernelRunscostCentreReportsizeLoggingCode commonOptionsprofilingEnclosurePyProg PyClassDefClassPyFunDefDefPyExceptCatchPyStmtTryWithAssignAssignOpRaiseReturnImportClassDefEscapePyArg ArgKeywordPyIdxIdxRangeIdxExpPyExpIntegerFloatStringRawStringLiteralCondCastListFieldDictNone $fPrettyPyExp $fPrettyPyArg $fPrettyPyIdx$fPrettyPyExcept$fPrettyPyClassDef$fPrettyPyFunDef$fPrettyPyStmt$fPrettyPyProg $fEqPyProg $fShowPyProg$fEqPyClassDef$fShowPyClassDef $fEqPyStmt $fShowPyStmt $fEqPyFunDef$fShowPyFunDef $fEqPyExcept$fShowPyExcept $fEqPyArg $fShowPyArg $fEqPyExp $fShowPyExp $fEqPyIdx $fShowPyIdxpreludeProgBaseprogDocprogDecsDecBaseValDecTypeDecSigDecModDecOpenDecLocalDec ImportDec ModParamBaseModParam modParamName modParamType modParamAbsmodParamLocation ModBindBaseModBindmodName modParams modSignaturemodExpmodDoc modLocation ModExpBaseModVar ModParens ModImportModDecsModApply ModAscript ModLambda SigBindBaseSigBindsigNamesigExpsigDocsigLoc TypeRefBaseTypeRef SigExpBaseSigVar SigParensSigSpecsSigWithSigArrowSpecBaseValSpec TypeAbbrSpecTypeSpecModSpec IncludeSpecspecNamespecTypeParamsspecTypespecDoc specLocation TypeParamBase TypeParamDim TypeParamType LiftednessUnlifted SizeLiftedLifted TypeBindBaseTypeBind typeAliastypeLiftedness typeParamstypeExptypeElabtypeDoctypeBindLocation ValBindBaseValBindvalBindEntryPoint valBindNamevalBindRetDeclvalBindRetTypevalBindTypeParams valBindParams valBindBody valBindDoc valBindAttrsvalBindLocation entryParams entryReturn EntryType entryType entryAscribed DocCommentPatBaseTuplePat RecordPat PatParensIdWildcard PatAscriptionPatLit PatConstrPatAttr PatLitInt PatLitFloat PatLitPrim LoopFormBaseForInCaseBaseCasePat FieldBaseRecordFieldExplicitRecordFieldImplicitExpBaseLiteralIntLitFloatLitParens QualParensTupLit RecordLitProjectNegateConstr RecordUpdate OpSection OpSectionLeftOpSectionRightProjectSection IndexSectionAscriptAppExpAppRes appResType appResExt AppExpBaseCoerceRangeLetPatLetFunLetWithMatch SizeBindersizeNamesizeLocQualName qualQualsqualLeaf SliceBase DimIndexBase InclusivenessDownToExclusive ToInclusive UpToExclusiveBacktickPlusMinusTimesDivideModQuotRemShiftRShiftLBandBorEqualNotEqualLessLeqGreaterGeq PipeRightPipeLeft IdentBase identSrcLoc RecordDietSumDietFuncDiet TypeDeclBaseTypeDecl declaredType expandedType TypeArgExp TypeArgExpDimTypeArgExpTypeTypeExpTEVarTETupleTERecordTEArrayTEUniqueTEApplyTEArrowTESumTEDimDimExp DimExpNamed DimExpConst DimExpAny PatRetType StructRetType ValueType StructTypePatTypeAliasingAlias AliasBound AliasFreealiasVarTypeArg TypeArgDim TypeArgTypeScalarScalarTypeBaseTypeVarSumArrow RetTypeBaseretDimsretTypePNameNamedUnnamedTypeName typeQualstypeLeaf ShapeDeclDimDeclNamedDimConstDimAnyDimArrayDim unifyDimsAttrInfoAttrAtomAtomNameAtomInt IsPrimValue primValue SignedValue UnsignedValueSignedUnsignedInfounInfoNoInfoShowabletypeNameFromQualNamequalNameFromTypeName typeParamName$fTraversableNoInfo$fFoldableNoInfo$fFunctorNoInfo$fTraversableInfo$fFoldableInfo $fFunctorInfo$fIsPrimValueBool$fIsPrimValueDouble$fIsPrimValueFloat$fIsPrimValueWord64$fIsPrimValueWord32$fIsPrimValueWord16$fIsPrimValueWord8$fIsPrimValueInt64$fIsPrimValueInt32$fIsPrimValueInt16$fIsPrimValueInt8$fIsPrimValueInt $fArrayDim()$fMonoidShapeDecl$fSemigroupShapeDecl$fFunctorShapeDecl$fTraversableShapeDecl$fFoldableShapeDecl $fOrdTypeName $fEqTypeName $fOrdPName $fEqPName$fFoldableTypeArg$fFunctorTypeArg$fTraversableTypeArg$fBifoldableScalarTypeBase$fBifunctorScalarTypeBase$fBitraversableScalarTypeBase$fBifoldableRetTypeBase$fBifunctorRetTypeBase$fBitraversableRetTypeBase$fTraversableInclusiveness$fFoldableInclusiveness$fFunctorInclusiveness$fLocatedInclusiveness$fTraversableQualName$fFoldableQualName$fFunctorQualName $fOrdQualName$fOrdQualName0 $fEqQualName $fEqQualName0$fLocatedTypeArgExp$fLocatedTypeExp$fArrayDimDimDecl$fTraversableDimDecl$fFoldableDimDecl$fFunctorDimDecl$fLocatedTypeDeclBase$fLocatedIdentBase$fOrdIdentBase $fEqIdentBase$fLocatedSizeBinder$fLocatedPatBase$fLocatedDocComment$fShowableInfovn$fShowableNoInfovn$fLocatedTypeParamBase$fTraversableTypeParamBase$fFoldableTypeParamBase$fFunctorTypeParamBase$fLocatedTypeBindBase$fLocatedCaseBase$fLocatedFieldBase$fLocatedExpBase$fLocatedAppExpBase$fLocatedValBindBase$fLocatedTypeRefBase$fLocatedSigExpBase$fLocatedSpecBase$fLocatedSigBindBase$fLocatedModParamBase$fLocatedDecBase$fLocatedModBindBase$fLocatedModExpBase$fEqTypeParamBase$fOrdTypeParamBase$fShowTypeParamBase$fEqLiftedness$fOrdLiftedness$fShowLiftedness$fShowEntryType$fShowDocComment $fEqPatLit $fOrdPatLit $fShowPatLit $fEqAppRes $fOrdAppRes $fShowAppRes$fEqSizeBinder$fOrdSizeBinder$fShowSizeBinder $fShowDimDecl $fShowTypeExp$fShowTypeArgExp $fShowDimExp$fShowQualName$fEqInclusiveness$fOrdInclusiveness$fShowInclusiveness $fEnumBinOp$fBoundedBinOp $fEqValue $fShowValue $fEqAlias $fOrdAlias $fShowAlias $fEqTypeArg $fOrdTypeArg $fShowTypeArg$fEqScalarTypeBase$fOrdScalarTypeBase$fShowScalarTypeBase$fEqRetTypeBase$fOrdRetTypeBase$fShowRetTypeBase $fShowPName$fShowTypeName $fEqShapeDecl$fOrdShapeDecl$fShowShapeDecl $fEqAttrInfo $fOrdAttrInfo$fShowAttrInfo $fEqAttrAtom $fOrdAttrAtom$fShowAttrAtom$fEqInfo $fOrdInfo $fShowInfo $fEqNoInfo $fOrdNoInfo $fShowNoInfo$fShowProgBase $fShowDecBase$fShowModParamBase$fShowModBindBase$fShowModExpBase$fShowSigBindBase$fShowTypeRefBase$fShowSigExpBase$fShowSpecBase$fShowTypeBindBase$fShowValBindBase $fOrdPatBase $fEqPatBase $fShowPatBase$fOrdLoopFormBase$fEqLoopFormBase$fShowLoopFormBase $fOrdCaseBase $fEqCaseBase$fShowCaseBase$fOrdFieldBase $fEqFieldBase$fShowFieldBase $fOrdExpBase $fEqExpBase $fShowExpBase$fOrdAppExpBase$fEqAppExpBase$fShowAppExpBase$fOrdDimIndexBase$fEqDimIndexBase$fShowDimIndexBase$fShowIdentBase$fOrdTypeDeclBase$fEqTypeDeclBase$fShowTypeDeclBase$fOrdTypeArgExp$fOrdTypeArgExp0$fEqTypeArgExp$fEqTypeArgExp0 $fOrdTypeExp $fOrdTypeExp0 $fEqTypeExp $fEqTypeExp0 $fOrdDimExp $fOrdDimExp0 $fEqDimExp $fEqDimExp0 $fOrdDimDecl $fEqDimDecl UncheckedCase UncheckedProg UncheckedSpec UncheckedDecUncheckedValBind UncheckedPatUncheckedTypeParamUncheckedSigExpUncheckedModExp UncheckedExpUncheckedSliceUncheckedDimIndexUncheckedIdentUncheckedTypeDeclUncheckedTypeExp UncheckedType IntrinsicIntrinsicMonoFunIntrinsicOverloadedFunIntrinsicPolyFun IntrinsicTypeIntrinsicEqualityDimPos PosImmediatePosParam PosReturn nestedDimsnoSizes traverseDimsmustBeExplicitInTypemustBeExplicitaliases toStructuraltoStruct fromStruct tupleRecord isTupleRecordareTupleFields tupleFieldstupleFieldNames sortFields sortConstrs isTypeParam isSizeParamcombineTypeShapes matchDims setUniqueness setAliases addAliases valueType foldFunType unfoldFunTypevalBindTypeScheme valBindBoundfunTypetypeVars orderZeropatternDimNames typeDimNamespatternOrderZero patternMap patternTypepatternStructType patternParamnamesToPrimTypes intrinsicsmaxIntrinsicTagqualNamequalifytypeName progImports decImportsprogModuleTypesidentifierReferenceleadingOperator $fEqDimPos $fOrdDimPos $fShowDimPosAnnotunAnnotIsNamepprName prettyName$fPrettyLiftedness$fPrettyPatLit$fPrettyTypeArg$fPrettyShapeDecl$fPrettyShapeDecl0$fPrettyShapeDecl1$fPrettyTypeParamBase$fPrettyAttrInfo$fPrettyAttrAtom$fPrettySizeBinder$fPrettyIdentBase$fPrettyQualName$fPrettyTypeArgExp$fPrettyTypeExp$fPrettyScalarTypeBase$fPrettyRetTypeBase$fPrettyShapeDecl2$fPrettyDimExp$fPrettyDimDecl $fIsNameName $fIsNameVName$fPrettyModBindBase$fPrettyModParamBase$fPrettySigBindBase$fPrettySigExpBase$fPrettySpecBase$fPrettyValBindBase$fPrettyTypeBindBase$fPrettyModExpBase$fPrettyDecBase$fPrettyProgBase$fPrettyPatBase$fPrettyLoopFormBase$fPrettyCaseBase$fPrettyFieldBase$fPrettyExpBase$fPrettyAppExpBase$fPrettyDimIndexBase$fPrettyTypeDeclBase $fAnnotInfo $fAnnotNoInfoTokenIDINDEXING QUALINDEXING QUALPARENSYMBOL CONSTRUCTOR PROJ_INTFIELDINTLIT STRINGLITI8LITI16LITI32LITI64LITU8LITU16LITU32LITU64LITFLOATLITF16LITF32LITF64LITCHARLITCOLONCOLON_GT BACKSLASH APOSTROPHEAPOSTROPHE_THEN_HATAPOSTROPHE_THEN_TILDEBACKTICK HASH_LBRACKETDOTTWO_DOTS TWO_DOTS_LT TWO_DOTS_GT THREE_DOTSLPARRPARRPAR_THEN_LBRACKETLBRACKETRBRACKETLCURLYRCURLYCOMMA UNDERSCORE RIGHT_ARROW QUESTION_MARKEQUASTERISKNEGATEBANGDOLLARLTHHATTILDEPIPEIFTHENELSELETLOOPINFORDOWITHASSERTTRUEFALSEWHILEINCLUDEIMPORTENTRYTYPEMODULEVALOPENLOCALMATCHCASEDOCEOFLscanTokensText ParseErrorparseDecOrExpIncrM parseFuthark parseModExp parseType parseValue parseValuesCase ScalarType TypeParam StructTypeArgSpecSigExpModExp envVtable envTypeTable envSigTable envModTable envNameMapNameMapBoundV TypeBindingTypeAbbrMTymtyAbsmtyModFunSig funSigAbs funSigMod funSigMtyModEnvModFunTySet NamespaceTerm SignatureImports FileModulefileAbsfileEnvfileProg ImportNamemkInitialImport mkImportFromincludeToFilePathincludeToString$fLocatedImportName$fPrettyNamespace $fPrettyEnv $fPrettyMod $fPrettyMTy $fMonoidEnv$fSemigroupEnv $fShowEnv $fShowMTy $fShowMod $fShowFunSig $fShowBoundV$fEqTypeBinding$fShowTypeBinding $fEqNamespace$fOrdNamespace$fShowNamespace$fEnumNamespace$fEqImportName$fOrdImportName$fShowImportNameCtxctxEnv ctxImportsInterpreterError ValuePrim ValueArrayExtOp ExtOpTrace ExtOpBreak ExtOpError BreakReason BreakPointBreakNaN StackFrame stackFrameLoc stackFrameCtx isEmptyArrayprettyEmptyArray fromTupletypeCheckerEnv initialCtx interpretExp interpretDecinterpretImportinterpretFunction $fPrettyShape$fShowInterpreterError$fPrettyIndexing$fFunctorExtOp$fLocatedStackFrame $fMonadEvalM$fApplicativeEvalM$fFunctorEvalM$fMonadFreeExtOpEvalM$fMonadReader(,)EvalM$fMonadStateMapEvalM $fEqShape $fShowShape$fFunctorShape$fFoldableShape$fTraversableShapeinternaliseParamTypesinternaliseLoopParamTypeinternaliseReturnTypeinternaliseLambdaReturnTypeinternaliseEntryReturnTypeinternaliseTypeinternaliseSumTypeinternalisedTypeSizeinternalisePrimTypeinternalisePrimValue$fFunctorInternaliseTypeM$fApplicativeInternaliseTypeM$fMonadInternaliseTypeM%$fMonadStateTypeStateInternaliseTypeMInternaliseLambdainternaliseMapLambdainternaliseStreamMapLambdainternaliseFoldLambdainternaliseStreamLambdainternalisePartitionLambdaNameSet unNameSetidentsizesizesfreeVarspatVars$fMonoidNameSet$fSemigroupNameSet $fShowNameSetinternaliseAttrinternaliseAttrsbindingFParamsbindingLoopParamsbindingLambdaParams transformProg ASTMappableastMap ASTMappermapOnExp mapOnName mapOnQualNamemapOnStructType mapOnPatTypemapOnStructRetTypemapOnPatRetTypebareExp$fASTMappable(,,)$fASTMappable(,)$fASTMappableNonEmpty$fASTMappable[]$fASTMappableInfo$fASTMappableCaseBase$fASTMappableFieldBase$fASTMappablePatBase$fASTMappableSizeBinder$fASTMappableIdentBase$fASTMappableTypeDeclBase$fASTMappableRetTypeBase$fASTMappableRetTypeBase0$fASTMappableTypeBase$fASTMappableTypeBase0$fASTMappableAppRes$fASTMappableSet$fASTMappableAlias$fASTMappableDimIndexBase$fASTMappableTypeParamBase$fASTMappableDimDecl$fASTMappableDimExp$fASTMappableTypeArgExp$fASTMappableTypeExp$fASTMappableLoopFormBase$fASTMappableExpBase$fASTMappableAppExpBaseAtPosAtNameBoundTo BoundTerm BoundModuleBoundModuleType BoundTypeboundLocatPos $fEqAtPos $fShowAtPos$fEqDef $fShowDef $fEqBoundTo $fShowBoundTo$fMonadFreshNamesLiftM$fFunctorLiftM$fApplicativeLiftM $fMonadLiftM$fMonadReaderEnvLiftM$fMonadStateLiftStateLiftM $fMonoidScope$fSemigroupScope$fApplicativeTransformM$fFunctorTransformM$fMonadTransformM$fMonadFreshNamesTransformM$fMonadReaderEnvTransformM$fMonadWriterDListTransformM $fShowScope$fMonadFreshNamesDefM $fEqSizeSubst$fOrdSizeSubst$fShowSizeSubst $fFunctorDefM$fApplicativeDefM $fMonadDefM$fMonadReader(,)DefM$fMonadState(,)DefM $fShowBinding$fShowStaticVal $fShowExtExp unmatched $fPrettyMatch $fEqMatch $fOrdMatch $fShowMatch $fEqConstr $fOrdConstr $fShowConstrWarnings anyWarnings singleWarningsingleWarning'$fPrettyWarnings$fMonoidWarnings$fSemigroupWarningstoExp' toInt64Exp toBoolExpTVImpMVTableVarEntryArrayVar ScalarVarMemVarAccVar ScalarEntryentryScalarTypeMemEntry entryMemSpace ArrayEntry entryArrayLocentryArrayElemTypeMemLoc memLocName memLocShape memLocIxFunopsExpCompiler opsOpCompileropsStmsCompileropsCopyCompileropsAllocCompilers AllocCompiler CopyCompiler ExpCompiler StmsCompiler sliceMemLocsubImpM_subImpMcollectcollect'commentemitwarn emitFunction hasFunction compileBody compileBody'compileLoopBody compileStmsdefCompileStms defCompileExpdFParamsdLParamsdPrimVoldPrim_dPrimdPrimV_dPrimVdPrimVEdScopedArrayeverythingVolatilemkTVtvSizetvExptvVarlocalDefaultSpace askFunctionnewVNameForFun nameForFunaskEnvlocalEnvlocalOps getVTable localVTable lookupArray lookupMemory lookupAccfullyIndexArrayfullyIndexArray'copyisMapTransposeCopycopyElementWisecopyDWIM copyDWIMFix compileAlloctypeSizeinBoundssForsWhilesCommentsIfsWhensUnlesssOp sDeclareMemsAlloc_sAllocsArray sArrayInMemsAllocArrayPerm sAllocArray sStaticArraysWritesUpdate sLoopNest<~~<--function dIndexSpace dIndexSpace'$fHasScopeSOACSImpM$fMonadFreshNamesImpM $fFunctorImpM$fApplicativeImpM $fMonadImpM$fMonadStateImpStateImpM$fMonadReaderEnvImpM$fShowValueDestination$fShowVarEntry$fShowScalarEntry$fShowMemEntry$fShowArrayEntry $fEqMemLoc $fShowMemLoc AtomicUpdate AtomicPrim AtomicCAS AtomicLockingLocking lockingArraylockingIsUnlocked lockingToLocklockingToUnlocklockingMapping MulticoreGenHostEnv hostAtomics hostLocksLocks locksArray locksCount AtomicBinOp segOpStringgetSpacegetIterationDomaingetReturnParamsrenameSegBinOpcompileThreadResult freeParamsgroupResultArraysdecideScheduling'decideSchedulingextractAllocationsrenameHistOpLambdaatomicUpdateLockingcompileSegScan compileSegRedcompileSegRed' compileSegMapcompileSegHistgenerateContext cliOptions operationsDoAtomicUpdateKernelConstantskernelGlobalThreadIdkernelLocalThreadId kernelGroupIdkernelGlobalThreadIdVarkernelLocalThreadIdVarkernelGroupIdVarkernelNumThreadskernelWaveSizekernelThreadActivekernelLocalIdMap InKernelGen CallKernelGen KernelEnv kernelAtomicskernelConstants kernelLocks hostTargetCUDAprecomputeSegOpIDskeyWithEntryPoint kernelLoop groupLoopgroupCoverSpacecomputeThreadChunkSizeisActive groupReduce groupScanvirtualiseGroups sKernelThread sKernelGroup sReplicatesIotasCopycompileGroupResult DoSegBody $fEqPassage $fOrdPassagecompileProgOpenCLcompileProgCUDAMonadTypeCheckernewID newTypeName bindNameMapbindVal checkQualName lookupMod checkNamedDim typeError ImportTableNotesaNote withIndexLinkunappliedFunctorunknownVariable unknownType underscoreUserunTypeM askImportName atTopLevelenteringModule lookupMTy lookupImport checkName bindSpacedqualifyTypeVars badOnLeft anySignedTypeanyUnsignedType anyIntType anyFloatType anyNumberType anyPrimTypeintrinsicsNameMaptopLevelNameMap mkTypeVarName checkAttr $fPrettyNote $fPrettyNotes$fPrettyTypeError$fMonadErrorTypeErrorTypeM$fMonadTypeCheckerTypeM$fMonadReaderContextTypeM$fMonadStateTypeStateTypeM$fSemigroupNotes $fMonoidNotes applySubstTypeSubsSubst PrimSubst unifyTypesU subuniqueOf renameRetType checkTypeExpcheckForDuplicateNamescheckTypeParamstypeParamToArg substFromAbbr substTypesAny$fFunctorSubst $fPrettySubst$fSubstitutablePatBase$fSubstitutableShapeDecl$fSubstitutableDimDecl$fSubstitutableTypeBase$fSubstitutableTypeBase0$fSubstitutableRetTypeBase$fSubstitutableRetTypeBase0 $fShowSubst MonadUnifygetConstraintsputConstraintsmodifyConstraints newTypeVar newDimVarcurLevel matchError unifyErrorRigidityRigidNonrigid RigidSourceRigidArgRigidRet RigidLoop RigidSlice RigidRange RigidBound RigidCond RigidUnifyRigidOutOfScope RigidCoerce Constraints Constraint NoConstraint ParamType Overloaded HasFieldsEquality HasConstrs ParamSizeSizeUnknowableSizeLevelUsage BreadCrumbs noBreadCrumbshasNoBreadCrumbsmkUsagemkUsage'dimNotes normTypeFully normPatTypeinstantiateEmptyArrayDimsunifyexpect mustBeOneOf equalityType zeroOrderType arrayElemTypemustHaveConstr mustHaveFieldunifyMostCommon doUnification$fPrettyBreadCrumb$fPrettyBreadCrumbs$fLocatedUsage $fPrettyUsage$fLocatedConstraint$fMonadUnifyUnifyM $fMonadUnifyM$fFunctorUnifyM$fApplicativeUnifyM$fMonadState(,)UnifyM$fMonadErrorTypeErrorUnifyM $fEqRigidity $fOrdRigidity$fShowRigidity$fShowConstraint$fEqRigidSource$fOrdRigidSource$fShowRigidSource$fPrettyMonoSize $fEqMonoSize$fFunctorMonoM$fApplicativeMonoM $fMonadMonoM$fMonadReaderEnvMonoM$fMonadWriterSeqMonoM$fMonadFreshNamesMonoM$fShowMonoSizeinternaliseProg TermTypeM TermTypeStatestateConstraints stateCounter stateDimTable stateNames stateOccs NameReason NameAppRes SizeSource SourceArg SourceBound SourceSlice TermScope scopeVtablescopeTypeTable scopeModTable scopeNameMapTermEnv termScope termChecking termLevelChecking CheckingApplyCheckingReturnCheckingAscriptionCheckingLetGeneraliseCheckingParams CheckingPatCheckingLoopBodyCheckingLoopInitialCheckingRecordUpdateCheckingRequiredCheckingBranches InferredType NoneInferredAscribed ValBinding OverloadedF EqualityF WasConsumedLocalityLocalGlobal Occurrences Occurrenceobservedconsumedlocation observation consumptioncheckOccurrences allConsumed allOccurringanyConsumptionseqOccurrencesuseAfterConsumebadLetWithValue returnAliaseduniqueReturnAliasedunexpectedType notConsumable unusedSizewithEnv liftTypeM constrain onFailureextSizeincLevelexpType expTypeFully newArrayTypeallDimsFreshInType updateTypesunifiescheckTypeExpNonrigidcheckTypeExpRigidmaybeDimFromExp dimFromExp dimFromArg noSizeEscapetapOccurrencescollectOccurrences sequentiallyoccurobserveonlySelfAliasingnoUniqueremoveSeminullOccurrencescheckIfConsumable consuming runTermTypeM$fLocatedOccurrence$fPrettyChecking$fSemigroupTermScope $fOrdFName $fEqFName$fMonadTypeCheckerTermTypeM$fMonadUnifyTermTypeM$fMonadTermTypeM$fFunctorTermTypeM$fApplicativeTermTypeM$fMonadReaderTermEnvTermTypeM"$fMonadStateTermTypeStateTermTypeM$fMonadErrorTypeErrorTermTypeM$fEqSizeSource$fOrdSizeSource$fShowSizeSource $fShowFName$fShowTermScope$fShowValBinding$fShowLocality$fEqOccurrence$fShowOccurrence doNotShadow boundAliases bindingIdent bindingSizes bindingPatcheckPat bindingParams CheckedLoop UncheckedLoop checkDoLoop checkOneExp checkFunDef$fPrettyUnmatched$fFunctorUnmatched$fShowUnmatchednewNamesForMTy refineEnv matchMTys applyFunctorcheckDec checkModExp initialEnvBasis basisImportsbasisNameSource basisRoots emptyBasisreadUntypedLibrary readLibrary readImports dumpErrorrunCompilerOnProgramrunPipelineOnProgram readProgramreadUntypedProgramreadProgramOrDiereadUntypedProgramOrDiehandleWarningsversion versionString FunOptDescrmainWithOptions optionsError CompilerMode ToLibrary ToExecutableToServerCompilerOption compilerMain$fEqCompilerMode$fOrdCompilerMode$fShowCompilerMode ConstructorcompInit CompilerEnv envOperations envVarExpopsEntryOutput opsEntryInput EntryInput EntryOutputemptyConstructor simpleCall compileName compileDim unpackDimcompilePrimTypecompilePrimTypeExtcompilePrimToNpcompilePrimToExtNpcompilePrimValue compileVar$fMonadWriter[]CompilerM openClInitmain $fOrdTestCase $fEqTestCase$fShowTestCase $fEqTestMode$fShowTestMode$fShowProgConfig$fEqTestResult$fShowTestResult$fMonadLoggerPkgM$fMonadPkgRegistryPkgM$fMonadFailPkgM $fMonadPkgM $fFunctorPkgM$fApplicativePkgM $fMonadIOPkgM$fMonadReaderPkgConfigPkgM mainImportsmainHash mainDataget$fPrettyDirective $fEqFailure $fOrdFailure $fShowFailure$fFunctorScriptM$fApplicativeScriptM$fMonadScriptM$fMonadErrorTextScriptM$fMonadFailScriptM$fMonadIOScriptM$fMonadStateStateScriptM $fShowBlock$fShowDirective$fShowVideoParams$fUniformRangeHalf$fEqOutputFormat$fOrdOutputFormat$fShowOutputFormat$fEqSkipReason$fShowDatasetResult renderFiles$fFunctorFutharkiM$fApplicativeFutharkiM$fMonadFutharkiM"$fMonadStateFutharkiStateFutharkiM$fMonadIOFutharkiM$fMonadErrorStopReasonFutharkiM printActionprintAliasesActioncallGraphAction metricsActionimpCodeGenActionkernelImpCodeGenActionmulticoreImpCodeGenActioncompileCActioncompileOpenCLActioncompileCUDAActioncompileMulticoreActioncompilePythonActioncompilePyOpenCLActioncompileCtoWASMActioncompileMulticoreToWASMAction$fPrettyUntypedPassState $fRepresentationUntypedPassState$fRepresentationUntypedActionGHC.Base GHC.MaybeNothingGHC.IOFilePath Data.Foldablemaximummap Data.EitherpartitionEithersGHC.ListsplitAtprocess-extras-0.7.4-cfe025889a0f688cd5293377470835a5c536b15015e1af2c97fe791455f2d234System.Process.ByteStringreadProcessWithExitCodeghc-prim GHC.TypesIOLeftGHC.RealIntegral displaySLoc displayLoc displaySPos displayPosunLocnoLocsrcspan<-->locEndlocStart advancePoslinePosstartPosposCoffposColposLineposFileNoLoc IsLocationfromPosfromLoc RelocatablerelocControl.Monad.IO.ClassMonadIO text-1.2.4.1Data.Text.InternalTextText.PrettyPrint.Mainland.ClasspprintPrettypprListpprpprPrecFuthark.Data.Reader readValuescompareSeveralValues Tolerance valueElems valueShape valueElemTypevalueTypeTextNoDims valueTypeText primTypeBytes primTypeTextVectorF64ValueF32ValueF16ValueU64ValueU32ValueU16ValueU8ValueI64ValueI32ValueI8ValueI16ValueF64F32F16U64U32U16U8I64I32I16I8GetValuegetValuePutValueputValue PutValue1 putValue1futhark-server-1.1.2.0-b8659b557f3375b35f0027c917c8cf8829a26018ed9aea5f077e6e4b9df6b093Futhark.ServerServer withServer GHC.ClassesOrdEqinteger-wired-inGHC.Integer.TypeRationalmempty==MonoidTruetransformers-0.5.6.2Control.Monad.Trans.ReaderReaderGHC.ErrerrorData.Functor.IdentityIdentityEQLTFunctor TraversableGHC.NumNumDoublelengthControl.Monad.FailfailMaybeEitherGHC.ShowShowControl.CategoryCategoryJust Control.MonadguardjoinMonadreturn>>=>>fmap<$Control.Monad.FixMonadFixmfix MonadFailsequencemapM MonadPlusmzeromplusliftIOmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforMmsum sequence_forM_mapM_ Data.Functionfix Data.FunctorvoidapliftM5liftM4liftM3liftM2liftMwhen=<<Control.Monad.Trans.Class MonadTransliftReaderT runReaderT mapReaderTControl.Monad.Reader.Classasks MonadReaderreaderasklocal runReader mapReader withReader withReaderT segOpType Semigroup scanTokensshow ParserMonadprog futharkType expression modExpressionanyValue anyValuesparseHappyStkMemoryDestinationthreadOperationsgetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirNoteSystem.Console.GetOptgetOpt'getOpt usageInfoArgOrder ReturnInOrder RequireOrderPermuteOptDescrArgDescrOptArgNoArgReqArg