API tools faq
paste
logicmoo

Untitled

logicmoo
Apr 26th, 2018
212
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Prolog 9.67 KB | None | 0 0
raw download clone embed print report
  1. true.
  2.  
  3. baseKB:  ?- repl.
  4.  
  5. __        ___    __  __        ____ _
  6. \ \      / / \  |  \/  |      / ___| |
  7.  \ \ /\ / / _ \ | |\/| |_____| |   | |
  8.   \ V  V / ___ \| |  | |_____| |___| |___
  9.    \_/\_/_/   \_\_|  |_|      \____|_____|
  10.  
  11. Common Lisp, written in Prolog
  12. ```
  13. ```cl
  14. CL-USER> (defun nconc (&optional lst &rest rest)
  15. CL-USER>>>   (if rest
  16. CL-USER>>>       (let ((rest-conc (apply #'nconc rest)))
  17. CL-USER>>>         (if (consp lst)
  18. CL-USER>>>             (progn (setf (cdr (last lst)) rest-conc)
  19. CL-USER>>>                    lst)
  20. CL-USER>>>             rest-conc))
  21. CL-USER>>>       lst))
  22. ```
  23. ```prolog
  24. :- lisp_compiled_eval(
  25.                      [ defun,
  26.                        nconc,
  27.                        [c38_optional, u_lst, c38_rest, rest],
  28.  
  29.                        [ if,
  30.                          rest,
  31.  
  32.                          [ let,
  33.                            [[u_rest_conc, [apply, function(nconc), rest]]],
  34.  
  35.                            [ if,
  36.                              [consp, u_lst],
  37.  
  38.                              [ progn,
  39.                                [setf, [cdr, [last, u_lst]], u_rest_conc],
  40.                                u_lst
  41.                              ],
  42.                              u_rest_conc
  43.                            ]
  44.                          ],
  45.                          u_lst
  46.                        ]
  47.                      ]).
  48. ## COMPILER
  49. :- side_effect((compile_each([name='GLOBAL', environ=env_1], LEnv, [], [], true), append([[last, u_lst]], [CAR21, CAR], [[last, u_lst], CAR21, CAR]), setf_inverse_op(cdr, rplacd))).
  50. :- side_effect((compile_each([name='GLOBAL', environ=env_1], LEnv, [], [], true), append([[last, u_lst]], [CAR21, CAR], [[last, u_lst], CAR21, CAR]), setf_inverse_op(cdr, rplacd))).
  51. % 649,509 inferences, 0.133 CPU in 0.135 seconds (99% CPU, 4880732 Lips)
  52. lambda_def(defun, nconc, f_nconc, [c38_optional, u_lst, c38_rest, rest], [[if, rest, [let, [[u_rest_conc, [apply, function(nconc), rest]]], [if, [consp, u_lst], [progn, [setf, [cdr, [last, u_lst]], u_rest_conc], u_lst], u_rest_conc]], u_lst]]).
  53. arglist_info(nconc, f_nconc, [c38_optional, u_lst, c38_rest, rest], arginfo{all:[u_lst], allow_other_keys:0, aux:0, body:0, complex:[opt, rest], env:0, key:0, names:[u_lst, rest], opt:[u_lst], outer:ReplEnv, req:0, rest:[rest], sublists:0, whole:0}).
  54. init_args(0, f_nconc).
  55.  
  56. ```
  57.  
  58. ### Compiled Function: `CL:NCONC`
  59. ```prolog
  60. f_nconc(RestNKeys, FnResult) :-
  61.        GEnv=[bv(u_lst, Lst_In), bv(rest, Rest_In)],
  62.        opt_var(ReplEnv, u_lst, Lst_In, true, [], 1, _55777686, RestNKeys),
  63.        as_rest(rest, Rest_In, 1, RestNKeys),
  64.        catch(( ( get_var(GEnv, rest, IFTEST),
  65.                  (   IFTEST\==[]
  66.                  ->  get_var(GEnv, rest, Rest_Get14),
  67.                      f_nconc(Rest_Get14, Rest_conc_Init),
  68.                      LEnv=[bv(u_rest_conc, Rest_conc_Init)|GEnv],
  69.                      get_var(LEnv, u_lst, Lst_Get),
  70.                      (   is_consp(Lst_Get)
  71.                      ->  get_var(LEnv, u_lst, Lst_Get22),
  72.                          f_last(Lst_Get22, [], Rplacd_Param),
  73.                          get_var(LEnv, u_rest_conc, Rest_conc_Get),
  74.                          f_rplacd(Rplacd_Param, Rest_conc_Get, Rplacd_Ret),
  75.                          get_var(LEnv, u_lst, Lst_Get24),
  76.                          LetResult=Lst_Get24
  77.                      ;   get_var(LEnv, u_rest_conc, Rest_conc_Get25),
  78.                          LetResult=Rest_conc_Get25
  79.                      ),
  80.                      _55777936=LetResult
  81.                  ;   get_var(GEnv, u_lst, Lst_Get28),
  82.                      _55777936=Lst_Get28
  83.                  )
  84.                ),
  85.                _55777936=FnResult
  86.              ),
  87.              block_exit(nconc, FnResult),
  88.              true).
  89. :- set_opv(nconc, symbol_function, f_nconc),
  90.   DefunResult=nconc.
  91. ## EXEC
  92. % 292 inferences, 0.000 CPU in 0.000 seconds (100% CPU, 957581 Lips)
  93. NCONC
  94. ```
  95. ```cl
  96. CL-USER> (defun mapcan (fn &rest lsts)
  97. CL-USER>>>   (apply #'nconc (apply #'mapcar fn lsts)))
  98. ```
  99. ```prolog
  100. :- lisp_compiled_eval(
  101.                      [ defun,
  102.                        mapcan,
  103.                        [u_fn, c38_rest, u_lsts],
  104.  
  105.                        [ apply,
  106.                          function(nconc),
  107.                          [apply, function(mapcar), u_fn, u_lsts]
  108.                        ]
  109.                      ]).
  110. ## COMPILER
  111. % 171,410 inferences, 0.042 CPU in 0.042 seconds (100% CPU, 4061609 Lips)
  112. lambda_def(defun, mapcan, f_mapcan, [u_fn, c38_rest, u_lsts], [[apply, function(nconc), [apply, function(mapcar), u_fn, u_lsts]]]).
  113. arglist_info(mapcan, f_mapcan, [u_fn, c38_rest, u_lsts], arginfo{all:[u_fn], allow_other_keys:0, aux:0, body:0, complex:[rest], env:0, key:0, names:[u_fn, u_lsts], opt:0, outer:ReplEnv, req:[u_fn], rest:[u_lsts], sublists:0, whole:0}).
  114. init_args(2, f_mapcan).
  115.  
  116. ```
  117.  
  118. ### Compiled Function: `CL:MAPCAN`
  119. ```prolog
  120. f_mapcan(Fn_In, RestNKeys, FnResult) :-
  121.        GEnv=[bv(u_fn, Fn_In), bv(u_lsts, Lsts_In)],
  122.        as_rest(u_lsts, Lsts_In, 0, RestNKeys),
  123.        catch(( ( get_var(GEnv, u_fn, Fn_Get),
  124.                  get_var(GEnv, u_lsts, Lsts_Get),
  125.                  f_apply(f_mapcar, [Fn_Get, Lsts_Get], Nconc_Param),
  126.                  f_nconc(Nconc_Param, Nconc_Ret)
  127.                ),
  128.                Nconc_Ret=FnResult
  129.              ),
  130.              block_exit(mapcan, FnResult),
  131.              true).
  132. :- set_opv(mapcan, symbol_function, f_mapcan),
  133.   DefunResult=mapcan.
  134. ## EXEC
  135. % 292 inferences, 0.001 CPU in 0.001 seconds (100% CPU, 520194 Lips)
  136. MAPCAN
  137. ```
  138. ```cl
  139. CL-USER> (DEFUN permute (LIST)(IF LIST (MAPCAN #'(LAMBDA (x)(MAPCAR #'(LAMBDA (y)(CONS x y) )
  140. CL-USER>>>   (permute (REMOVE x LIST) ) ) ) LIST) '(NIL) ) )
  141. ```
  142. ```prolog
  143. :- lisp_compiled_eval(
  144.                       [ defun,
  145.                         u_permute,
  146.                         [list],
  147.  
  148.                         [ if,
  149.                           list,
  150.  
  151.                           [ mapcan,
  152.                             function(
  153.                                      [ lambda,
  154.                                        [u_x],
  155.  
  156.                                        [ mapcar,
  157.                                          function(
  158.                                                   [ lambda,
  159.                                                     [u_y],
  160.                                                     [cons, u_x, u_y]
  161.                                                   ]),
  162.                                          [u_permute, [remove, u_x, list]]
  163.                                        ]
  164.                                      ]),
  165.                             list
  166.                           ],
  167.                           [quote, [[]]]
  168.                         ]
  169.                       ]).
  170. ## COMPILER
  171. % 392,998 inferences, 0.089 CPU in 0.094 seconds (95% CPU, 4417651 Lips)
  172. lambda_def(defun, u_permute, f_u_permute, [list], [[if, list, [mapcan, function([lambda, [u_x], [mapcar, function([lambda, [u_y], [cons, u_x, u_y]]), [u_permute, [remove, u_x, list]]]]), list], [quote, [[]]]]]).
  173. arglist_info(u_permute, f_u_permute, [list], arginfo{all:[list], allow_other_keys:0, aux:0, body:0, complex:0, env:0, key:0, names:[list], opt:0, outer:ReplEnv, req:[list], rest:0, sublists:0, whole:0}).
  174.  init_args(x, f_u_permute).
  175.  
  176. ```
  177.  
  178. ### Compiled Function: `U::PERMUTE`
  179. ```prolog
  180. f_u_permute(List_In, FnResult) :-
  181.         GEnv=[bv(list, List_In)],
  182.         catch(( ( get_var(GEnv, list, IFTEST),
  183.                   (   IFTEST\==[]
  184.                   ->  get_var(GEnv, list, List_Get27),
  185.                       f_mapcan(closure(kw_function,
  186.                                        ClosureEnvironment25,
  187.                                        WholeArgs11,
  188.                                        LResult23,
  189.                                        [u_x],
  190.                                        ((append([X_In], RestNKeys10, WholeArgs11), ClosureEnvironment25=[[bv(u_x, X_In)]|GEnv], del_attr(RestNKeys10, freeze), true), get_var(ClosureEnvironment25, list, List_Get22), get_var(ClosureEnvironment25, u_x, X_Get21), f_remove(X_Get21, List_Get22, [], Permute_Param), f_u_permute(Permute_Param, Permute_Ret), f_mapcar(closure(kw_function, ClosureEnvironment, WholeArgs14, LResult, [u_y],  ((append([Y_In], RestNKeys13, WholeArgs14), ClosureEnvironment=[[bv(u_y, Y_In)]|ClosureEnvironment25], del_attr(RestNKeys13, freeze), true), get_var(ClosureEnvironment, u_x, X_Get), get_var(ClosureEnvironment, u_y, Y_Get), LResult=[X_Get|Y_Get]), [lambda, [u_y], [cons, u_x, u_y]]), [Permute_Ret], LResult23)),
  191.  
  192.                                        [ lambda,
  193.                                          [u_x],
  194.  
  195.                                          [ mapcar,
  196.                                            function(
  197.                                                     [ lambda,
  198.                                                       [u_y],
  199.                                                       [cons, u_x, u_y]
  200.                                                     ]),
  201.                                            [u_permute, [remove, u_x, list]]
  202.                                          ]
  203.                                        ]),
  204.                                List_Get27,
  205.                                [],
  206.                                TrueResult),
  207.                       _56964434=TrueResult
  208.                   ;   _56964434=[[]]
  209.                   )
  210.                 ),
  211.                 _56964434=FnResult
  212.               ),
  213.               block_exit(u_permute, FnResult),
  214.               true).
  215. :- set_opv(u_permute, symbol_function, f_u_permute),
  216.    DefunResult=u_permute.
  217. ## EXEC
  218. % 293 inferences, 0.001 CPU in 0.001 seconds (100% CPU, 423616 Lips)
  219. PERMUTE
  220. ```
  221. ```cl
  222. CL-USER>
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!