Remove debugging entry map_f.

[haskell/symantic.git] / symantic / Language / Symantic / Interpreting / Dup.hs

diff --git a/symantic/Language/Symantic/Interpreting/Dup.hs b/symantic/Language/Symantic/Interpreting/Dup.hs
index 1723fe0ff37b187b19ee63c4df055c0bf2c9dde5..f789ef61385e5c360dca71634b3601cefb0cba65 100644 (file)
--- a/symantic/Language/Symantic/Interpreting/Dup.hs
+++ b/symantic/Language/Symantic/Interpreting/Dup.hs
@@ -5,47 +5,47 @@
 --
 -- NOTE: this is a more verbose, less clear,
 -- and maybe less efficient alternative
--- to maintaining the universal polymorphism of @term@ at parsing time
--- as done with 'TermO';
+-- to maintaining the universal polymorphism of @term@
+-- at parsing time as done with 'Term';
 -- it is mainly here for the sake of curiosity.
 module Language.Symantic.Interpreting.Dup where
 
 -- | Interpreter's data.
-data DupI term1 term2 a
- =   DupI
- {   dupI_1 :: term1 a
- ,   dupI_2 :: term2 a
+data Dup term1 term2 a
+ =   Dup
+ {   dup_1 :: term1 a
+ ,   dup_2 :: term2 a
  }
 
-dupI0
+dup0
  :: (cl r, cl s)
  => (forall term. cl term => term a)
- -> DupI r s a
-dupI0 f = f `DupI` f
+ -> Dup r s a
+dup0 f = f `Dup` f
 
-dupI1
+dup1
  :: (cl r, cl s)
  => (forall term. cl term => term a -> term b)
- -> DupI r s a
- -> DupI r s b
-dupI1 f (a1 `DupI` a2) =
-       f a1 `DupI` f a2
+ -> Dup r s a
+ -> Dup r s b
+dup1 f (a1 `Dup` a2) =
+       f a1 `Dup` f a2
 
-dupI2
+dup2
  :: (cl r, cl s)
  => (forall term. cl term => term a -> term b -> term c)
- -> DupI r s a
- -> DupI r s b
- -> DupI r s c
-dupI2 f (a1 `DupI` a2) (b1 `DupI` b2) =
-       f a1 b1 `DupI` f a2 b2
+ -> Dup r s a
+ -> Dup r s b
+ -> Dup r s c
+dup2 f (a1 `Dup` a2) (b1 `Dup` b2) =
+       f a1 b1 `Dup` f a2 b2
 
-dupI3
+dup3
  :: (cl r, cl s)
  => (forall term. cl term => term a -> term b -> term c -> term d)
- -> DupI r s a
- -> DupI r s b
- -> DupI r s c
- -> DupI r s d
-dupI3 f (a1 `DupI` a2) (b1 `DupI` b2) (c1 `DupI` c2) =
-       f a1 b1 c1 `DupI` f a2 b2 c2
+ -> Dup r s a
+ -> Dup r s b
+ -> Dup r s c
+ -> Dup r s d
+dup3 f (a1 `Dup` a2) (b1 `Dup` b2) (c1 `Dup` c2) =
+       f a1 b1 c1 `Dup` f a2 b2 c2