jiamo

import os


"""
  0:      1:      2:      3:      4:
 aaaa    ....    aaaa    aaaa    ....
b    c  .    c  .    c  .    c  b    c
b    c  .    c  .    c  .    c  b    c
 ....    ....    dddd    dddd    dddd
e    f  .    f  e    .  .    f  .    f

jiamo

module SimpleEval where

import Prelude hiding (odd, even)
import Data.Dynamic


data Expr = Val Int | Add Expr Expr 
data Cont = HALT | EVAL Expr Cont | ADD Int Cont 

eval :: Expr -> Int

jiamo

#lang lazy


(define g
    (lambda (f)
      (lambda (n)
        (if (= n 0)
            1
            (* n (f (- n 1))))))) 
(define f

jiamo

#lang lazy


(define g
    (lambda (f)
      (lambda (n)
        (if (= n 0)
            1
            (* n (f (- n 1))))))) 
(define f

jiamo

module Can where

import Relation.Binary.PropositionalEquality as Eq
import Data.Nat.Properties as Pro
open Pro using (+-assoc; +-identityʳ; +-suc; +-comm)
open Eq using (_≡_; refl; cong; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; _≡⟨_⟩_; _∎)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_; _^_)

jiamo

#lang racket


;;(define Y 
;;    (lambda (f)
;;      ((lambda (x) (f (x x))) (lambda (x) (f (x x))))  ))

;;(define almost-Y 
;;    (lambda (f)
;;      ((lambda (x) (f (x x))) (lambda (x) (f (x x)))) ))

jiamo

#lang racket

(define identity (lambda (x) x))

(define (part-factorial0 self n)
  (if (= n 0)
      1
      (* n (self self (- n 1)))))  ;; note the extra "self" here the same as below

(part-factorial0 part-factorial0 5)

jiamo

#lang racket


;(Y f) = fixpoint-of-f
;(f fixpoint-of-f) = fixpoint-of-f
;(Y f) = fixpoint-of-f = (f fixpoint-of-f)
;(Y f) = (f (Y f))
(define (Y f) (f (Y f)))

(define Y-lambda

jiamo

#lang racket

(define (factorial n)
  (if (= n 0)
      1
      (* n (factorial (- n 1)))))


(define factorial_lambda
  (lambda (n)

jiamo

{-# LANGUAGE RebindableSyntax #-}

module Cartesian_product3 where

import Prelude hiding((>>=), return, Monad, fail)

-- begin help -----

class Applicative m => Monad m where  
    return :: a -> m a