Idris2/tests/idris2/reflection/reflection002/power.idr

import Language.Reflection

%language ElabReflection

powerFn : Nat -> TTImp
powerFn Z = `(const 1)
powerFn (S k) = `(\x => mult x (~(powerFn k) x))

-- Note: this example doesn't quite do what we want yet. Ideally, we'd find
-- a way to block reduction under the 'pure' while running the script
powerFn' : Nat -> Elab (Nat -> Nat)
powerFn' Z = pure (const 1)
powerFn' (S k)
    = do powerk <- powerFn' k
         pure (\x => mult (powerk x) x)

%macro
power : Nat -> Elab (Nat -> Nat)
power n = check (powerFn n)

%macro
power' : Nat -> Elab (Nat -> Nat)
power' n = powerFn' n

cube : Nat -> Nat
cube = power 3

cube' : Nat -> Nat
cube' = power' 3
Progress on elaborator reflection Add %runElab and start on scripts, although all they can do so far is check a term. This does gives us, sort of, "template Idris" (as demonstrated in test reflection002) 2020-05-31 03:36:54 +03:00			`import Language.Reflection`

			`%language ElabReflection`

			`powerFn : Nat -> TTImp`
			powerFn Z = `(const 1)
			powerFn (S k) = `(\x => mult x (~(powerFn k) x))

Improve elaborator reflection performance In a 'Bind', normalise the result of the first action, rather than quoting the HNF. This improves performance since the HNF could be quite big when quoted back. Ideally, we wouldn't have to quote and unquote here, and we can probably achieve this by tinkering with the evaluator. This has an unfortunate effect on the reflection002 test, in that the "typed template Idris" example now evaluates too much. But, I think the overall performance is too important for the primary motivation behind elaborator reflection. I will return to this! 2020-07-17 17:18:23 +03:00			`-- Note: this example doesn't quite do what we want yet. Ideally, we'd find`
			`-- a way to block reduction under the 'pure' while running the script`
Add alternative example to reflection002 A bit more typesafe... 2020-06-03 01:56:30 +03:00			`powerFn' : Nat -> Elab (Nat -> Nat)`
			`powerFn' Z = pure (const 1)`
Improve elaborator reflection performance In a 'Bind', normalise the result of the first action, rather than quoting the HNF. This improves performance since the HNF could be quite big when quoted back. Ideally, we wouldn't have to quote and unquote here, and we can probably achieve this by tinkering with the evaluator. This has an unfortunate effect on the reflection002 test, in that the "typed template Idris" example now evaluates too much. But, I think the overall performance is too important for the primary motivation behind elaborator reflection. I will return to this! 2020-07-17 17:18:23 +03:00			`powerFn' (S k)`
			`= do powerk <- powerFn' k`
			`pure (\x => mult (powerk x) x)`
Add alternative example to reflection002 A bit more typesafe... 2020-06-03 01:56:30 +03:00
Implement %macro flag A %macro must always be fully applied. Whenever the elaborator encounters a %macro application (except in a function LHS) it evaluates the application and sends the result to %runElab. So: %macro foo : args -> Elab TT ... def = foo a b c is equivalent to foo : args -> Elab TT ... def = %runElab foo a b c 2020-06-01 19:55:54 +03:00			`%macro`
In reflection, check now takes a concrete type So the type of Elab now gives the expected type that's being elaborated to, meaning that we can run 'check' in the middle of scripts and use the result. 2020-06-03 00:41:37 +03:00			`power : Nat -> Elab (Nat -> Nat)`
Implement %macro flag A %macro must always be fully applied. Whenever the elaborator encounters a %macro application (except in a function LHS) it evaluates the application and sends the result to %runElab. So: %macro foo : args -> Elab TT ... def = foo a b c is equivalent to foo : args -> Elab TT ... def = %runElab foo a b c 2020-06-01 19:55:54 +03:00			`power n = check (powerFn n)`

Add alternative example to reflection002 A bit more typesafe... 2020-06-03 01:56:30 +03:00			`%macro`
			`power' : Nat -> Elab (Nat -> Nat)`
			`power' n = powerFn' n`

Progress on elaborator reflection Add %runElab and start on scripts, although all they can do so far is check a term. This does gives us, sort of, "template Idris" (as demonstrated in test reflection002) 2020-05-31 03:36:54 +03:00			`cube : Nat -> Nat`
Implement %macro flag A %macro must always be fully applied. Whenever the elaborator encounters a %macro application (except in a function LHS) it evaluates the application and sends the result to %runElab. So: %macro foo : args -> Elab TT ... def = foo a b c is equivalent to foo : args -> Elab TT ... def = %runElab foo a b c 2020-06-01 19:55:54 +03:00			`cube = power 3`
Add alternative example to reflection002 A bit more typesafe... 2020-06-03 01:56:30 +03:00
			`cube' : Nat -> Nat`
			`cube' = power' 3`