Idris2/tests/idris2/basic019/expected

1/1: Building CaseBlock (CaseBlock.idr)
Main> Main.foo : (x : Nat) -> (case x of { 0 => Nat -> Nat ; S k => Nat })
Main> Prelude.elem : Foldable t => Eq a => a -> t a -> Bool
elem = elemBy (==)
Main> PrimIO.io_bind : (1 _ : IO a) -> (1 _ : (a -> IO b)) -> IO b
io_bind (MkIO fn) k = MkIO (\1 w => let MkIORes x' w' = fn w in let MkIO res = k x' in res w')
Main> Bye for now!
Add test script They don't all pass yet, for minor reasons. Coming shortly... Unfortunately the startup overhead for chez is really noticeable here! 2020-05-19 20:25:18 +03:00			`1/1: Building CaseBlock (CaseBlock.idr)`
[ doc ] `:printdef` for interface implementations (#2340) 2022-03-07 14:47:20 +03:00			`Main> Main.foo : (x : Nat) -> (case x of { 0 => Nat -> Nat ; S k => Nat })`
[ refactor ] Abstract Prelude.elem to work with all Foldables (#2294) 2022-02-02 00:34:29 +03:00			`Main> Prelude.elem : Foldable t => Eq a => a -> t a -> Bool`
[ refactor ] Index Pretty over the type of annotations (#2371) 2022-04-27 14:26:59 +03:00			`elem = elemBy (==)`
Allow _ for names in pi binders This is mostly to make it easier to write linear function types without having to invent names for everything, which might be noisy. Also it improves the display of linear function types when the name isn't used in the scope. 2020-05-25 15:14:51 +03:00			`Main> PrimIO.io_bind : (1 _ : IO a) -> (1 _ : (a -> IO b)) -> IO b`
Look at intermediate results in program search This has involved quite a bit of reorganisation and some improvements in resugaring so that the results look nice. In summary: * Expression search now gives back a RawImp rather than a checked term, which allows it to include case expressions * Case with one pattern is resugared to a destructuring let * Some name generation issues address in function generation We look at intermediate results for local variables which are functions that return a concrete type, or recursive calls that return a single constructor type. In these cases, we: * let bind the local variable/recursive call * generate a new definition for the scope, as a 'case' function When we recursively generate the definition, it's a bit more restricted so as not to explode the search space. We only take the first result, we only look one constructor deep, and we go right to left on variable splitting so only deconstruct the name we've just added. 2020-08-04 14:51:57 +03:00			`io_bind (MkIO fn) k = MkIO (\1 w => let MkIORes x' w' = fn w in let MkIO res = k x' in res w')`
Add test script They don't all pass yet, for minor reasons. Coming shortly... Unfortunately the startup overhead for chez is really noticeable here! 2020-05-19 20:25:18 +03:00			`Main> Bye for now!`