id int64 0 45.1k | file_name stringlengths 4 68 | file_path stringlengths 14 193 | content stringlengths 32 9.62M | size int64 32 9.62M | language stringclasses 1
value | extension stringclasses 6
values | total_lines int64 1 136k | avg_line_length float64 3 903k | max_line_length int64 3 4.51M | alphanum_fraction float64 0 1 | repo_name stringclasses 779
values | repo_stars int64 0 882 | repo_forks int64 0 108 | repo_open_issues int64 0 90 | repo_license stringclasses 8
values | repo_extraction_date stringclasses 146
values | sha stringlengths 64 64 | __index_level_0__ int64 0 45.1k | exdup_ids_cmlisp_stkv2 listlengths 1 47 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
32,206 | chapter-2.lisp | andlys_ansi-common-lisp/chapters/chapter-2.lisp | (defvar l (list 'a 'b 'c 'd 'e))
(car l)
(cdr l)
(car (cdr (cdr l)))
(third l)
(listp '(a b c))
(not (listp 1))
(and (member 'a l) t)
(defun is-even(n)
(if (numberp n)
(= (mod n 2) 0)
nil))
(member 'f '('a 'b 'c 'd 'e 'f 6 7 8))
(member-if #'is-even '('a 'b 'c 'd 'e 'f))
(print (is-even 1... | 1,425 | Common Lisp | .lisp | 62 | 18.967742 | 57 | 0.505263 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 05895e0a53e686da3a68f7013becd4f6e0687bbb87d63e10867390b67b6f10e2 | 32,206 | [
-1
] |
32,207 | chapter-6-ex.lisp | andlys_ansi-common-lisp/chapters/chapter-6-ex.lisp | ;;; ex-3
(defun len (&rest args) (length args))
(len)
(len nil)
(len 'a)
(len 'a 'b)
(len 'a 'b 'c)
;;; ex-6
;; closure technique used
;; description: function that takes one number and returns the greatest number
;; passed to it so far
(let (lst)
(defun highest (n)
(reduce #'max (push n lst))))
(highest 0)
(h... | 765 | Common Lisp | .lisp | 33 | 21.393939 | 78 | 0.68088 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | b820d34b221f3f8144deed7ce56b6d9bce40956c61de0c6de0019f58df176b47 | 32,207 | [
-1
] |
32,208 | chapter-6-utils.lisp | andlys_ansi-common-lisp/chapters/chapter-6-utils.lisp | ; *** fn ***
(defun single? (lst)
(and (consp lst) (null (cdr lst))))
(defun append1 (lst obj)
(append lst (list obj)))
(defun map-int (fn n)
(let ((acc nil))
(dotimes (i n)
(push (funcall fn i) acc))
(nreverse acc)))
(defun filter (fn lst)
(let ((acc nil))
(dolist (x lst)
(let ((va... | 394 | Common Lisp | .lisp | 16 | 20.5625 | 37 | 0.557641 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 65796588a87fdd9b041b58591d786d9ca1a1ff663fe879a77cb5613706b696b9 | 32,208 | [
-1
] |
32,209 | chapter-4-tree.lisp | andlys_ansi-common-lisp/chapters/chapter-4-tree.lisp | ;;; code from the book retyped here by me
(defstruct (node (:print-function
(lambda (node stream depth)
(format stream "#<~A>" (node-value node)))))
value
(left nil)
(right nil))
(defun bst-insert (obj bst less-cmp)
(if (null bst)
(make-node :value o... | 2,737 | Common Lisp | .lisp | 77 | 22.272727 | 79 | 0.450773 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 6644f9cda10a4b504266a565dbefa753cdd51b52edd88b143dc00f62df1d7cc2 | 32,209 | [
-1
] |
32,210 | chapter-4.lisp | andlys_ansi-common-lisp/chapters/chapter-4.lisp | (defparameter arr (make-array '(2 3) :initial-element nil))
(aref arr 0 0)
(setf (aref arr 0 0) 'b)
(setf *print-array* t)
(defparameter vec (make-array 4 :initial-element nil))
(vector "a" 'b 3)
(svref vec 0)
#| a multy-
line
comment
|#
;;;; Utilities for operations on sorted vector
;;; finds an element in a sor... | 8,583 | Common Lisp | .lisp | 258 | 24.813953 | 82 | 0.522507 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 52e2f32ece6a3f234b9909ec39949a6cf65df5954b6c0c8b0a96d2b607adb444 | 32,210 | [
-1
] |
32,241 | diff-sexp.lisp | nickziv_blip/diff-sexp.lisp | ;;; diff-sexp.lisp -- diffs s-expressions based on Levenshtein-like edit distance.
;; Author: Michael Weber <michaelw@foldr.org>
;; Date: 2005-09-03
;; Modified: 2005-09-04
;; Modified: 2005-09-07
;; Modified: 2005-09-15
;;
;; This code is in the Public Domain.
;;; Description:
;; DIFF-SEXP computes a diff between t... | 6,815 | Common Lisp | .lisp | 167 | 37.359281 | 85 | 0.674549 | nickziv/blip | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 83403ae918e8462e68e05abc253c03161121b7f5b656aab700c1310838820f00 | 32,241 | [
-1
] |
32,242 | envs.lisp | nickziv_blip/envs.lisp | ;;; This Source Code Form is subject to the terms of the Mozilla Public
;;; License, v. 2.0. If a copy of the MPL was not distributed with this
;;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
;;; Copyright 2017 Joyent, Inc.
;;; Copyright 2017 Nicholas Zivkovic
(defvar env-stack nil)
(defvar env-pool nil)... | 21,975 | Common Lisp | .lisp | 575 | 26.965217 | 87 | 0.509191 | nickziv/blip | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | d915a2a75e70a5ba25302498a18443d9d49c47d612a102148506fcb6bf58aa2a | 32,242 | [
-1
] |
32,243 | startup.lisp | nickziv_blip/startup.lisp | ;;; When loading, we need 2 passes to accomodate definition-after-use
;;; Could be avoided with FASL format but why bother?
(load "blip.lisp")
(reload)
| 152 | Common Lisp | .lisp | 4 | 37 | 69 | 0.756757 | nickziv/blip | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | c01251314c65c60317124ac09ebe0a90164d4b812350dc6f92d6d6f1830513b2 | 32,243 | [
-1
] |
32,244 | blip.lisp | nickziv_blip/blip.lisp | ;;; This Source Code Form is subject to the terms of the Mozilla Public
;;; License, v. 2.0. If a copy of the MPL was not distributed with this
;;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
;;; Copyright 2017 Joyent, Inc.
;;; Copyright 2017 Nicholas Zivkovic
(load "/opt/quicklisp/setup.lisp")
(ql:quick... | 170,932 | Common Lisp | .lisp | 4,752 | 27.609217 | 230 | 0.541792 | nickziv/blip | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 574a2f48fa3cae6c431276a3f401e56dab53e1bb7dd1b80b7d62058dce31b8fe | 32,244 | [
-1
] |
32,265 | parse.lisp | epeld_class-files/parse.lisp |
(in-package :java-parse)
(defun read-chunk (stream &optional (count 512))
"Rpead a chunk of unsigned bytes from a file stream. START can be negative and indicates
an offset from the end of the file"
(unless (< count 100000)
(error "Too high count ~a" count))
(let ((buffer (make-array `(,count) :element-t... | 14,488 | Common Lisp | .lisp | 318 | 37.069182 | 118 | 0.639794 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 6f745717f4c4102ae23b099ebe981339bc9e2c492bfd2e2dbc60e026240aa2f7 | 32,265 | [
-1
] |
32,266 | opcode-parse.lisp | epeld_class-files/opcode-parse.lisp |
(in-package :java-parse)
(loop for op in raw-opcodes when (search "invoke" (first op)) collect op)
(defvar raw-opcodes nil
"Cached list of opcodes")
(defun read-raw-opcodes ()
(with-open-file (in "opcodes.lisp"
:direction :input)
(read in)))
(setf raw-opcodes (read-raw-opcodes))
;;
;... | 4,128 | Common Lisp | .lisp | 96 | 36.760417 | 110 | 0.659825 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 969122a45b0d7bdc2ba9d930bbb7b2970b8bf9e446b7ccf1efcb0884f6f54d85 | 32,266 | [
-1
] |
32,267 | package.lisp | epeld_class-files/package.lisp |
(ql:quickload :zip)
(ql:quickload :flexi-streams)
(ql:quickload 'ieee-floats)
(defpackage :java
(:nicknames :java-class :java-parse :java-jar)
(:use :cl :ieee-floats :flexi-streams :zip)
(:export :read-jar
:java-class-name
:referenced-classes
:system-class-p
:standard... | 1,099 | Common Lisp | .lisp | 40 | 20.7 | 48 | 0.609943 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | fba6912edc511a76d2284f87d4993cf002d0b5284d0fd6498521e9d009ab585f | 32,267 | [
-1
] |
32,268 | server.lisp | epeld_class-files/server.lisp |
(in-package :server)
(defvar server-instance nil
"The global server instance, when running")
(defun start-server (&optional force)
"Start the server.."
(when (and server-instance
(not force))
(cerror "Continue anyway" "Server already running. Really start again?!"))
(setf server-instanc... | 4,461 | Common Lisp | .lisp | 105 | 33.695238 | 122 | 0.572825 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | da6f27cdb787c5e9515a77b230c86dc57f031729f9a9eb9490b3074187898052 | 32,268 | [
-1
] |
32,269 | jar.lisp | epeld_class-files/jar.lisp |
(in-package :java-jar)
(defun suffixp (suffix string)
"Return true if STRING is suffixed by SUFFIX"
(search suffix string :from-end t))
(defun system-class-p (string)
"Predicate for filtering out 'system'-like classes, e.g junit etc so that only user defined classes remain"
(or (search "org/junit" string)
... | 1,046 | Common Lisp | .lisp | 24 | 37.541667 | 109 | 0.662389 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | a59b78d346931d245729dd1960debc83cfe9e0364c52ec093a531d0488a64672 | 32,269 | [
-1
] |
32,270 | opcodes.lisp | epeld_class-files/opcodes.lisp |
(("aaload" "32" "0011 0010" "" "arrayref, index → value" "load onto the stack a reference from an array") ("aastore" "53" "0101 0011" "" "arrayref, index, value →" "store into a reference in an array") ("aconst_null" "01" "0000 0001" "" "→ null" "push a <i>null</i> reference onto the stack") ("aload" "19" "0001 1001" ... | 28,778 | Common Lisp | .lisp | 3 | 9,455.333333 | 27,974 | 0.67172 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 8b5c7e6cb93ccd9aef7d13e6d92457b74ce314f3408bded51dbb3ef1531af777 | 32,270 | [
-1
] |
32,271 | Sample.class | epeld_class-files/Sample.class | Êþº¾ 4
MY_INT I
ConstantValue ! MY_FLOAT FB0 MY_String Ljava/lang/String; <init> ()V Code LineNumberTable getIt ()Z <clinit>
SourceFile Sample.java
FIFTY FIVE
Sample java/lang/Object
I
... | 448 | Common Lisp | .cl | 5 | 88.6 | 172 | 0.324324 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 33284b979e1986a3b4c683e399abe343d572afa0c4e3fee5e72a74c91175a760 | 32,271 | [
-1
] |
32,272 | Main.class | epeld_class-files/Main.class | Êþº¾ 4
<init> ()V Code LineNumberTable Main ([Ljava/lang/String;)V
SourceFile Main.java HELLO java/lang/Object java/lang/System out Ljava/io/PrintStream; java/io/PrintStream println (Ljava/lang/String;)V ! *·... | 400 | Common Lisp | .cl | 7 | 56.142857 | 219 | 0.411168 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 1a7a5751bbe1ff176c542c3bcff707979f792668b65d1e096f0411de3b03be82 | 32,272 | [
-1
] |
32,277 | opcodes2.html | epeld_class-files/opcodes2.html | <table class="wikitable sortable">
<tr>
<th scope="col">Mnemonic</th>
<th scope="col">Opcode<br />
<i>(in hexadecimal)</i></th>
<th>Opcode (in binary)</th>
<th scope="col">Other bytes</th>
<th scope="col">Stack<br />
[before]→[after]</th>
<th scope="col" class="unsortable">Description</th>
</tr>
<tr>
<td>aaload</td>
<t... | 39,613 | Common Lisp | .l | 1,662 | 22.591456 | 317 | 0.668549 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 397980501fee3d2d2e608bfd25d03d5612464a7a0cb5ceb367eb9fc9bf877f4c | 32,277 | [
-1
] |
32,283 | Sample.java | epeld_class-files/Sample.java |
class Sample {
public static final int MY_INT = 33;
public static final float MY_FLOAT = 44;
public static volatile String MY_String = "FIFTY FIVE";
public boolean getIt() {
return true;
}
}
| 221 | Common Lisp | .l | 8 | 22.875 | 59 | 0.663507 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | c3ddbb4f8fe12f2071d9253182446f42fe18796f044a70833ec94ada83cbfc1f | 32,283 | [
-1
] |
32,284 | opcode.el | epeld_class-files/opcode.el |
(defun read-cell-content ()
(let (start content)
;; Enter cell
(nxml-down-element)
(setq start (point))
;; Go to end of cell content
(nxml-up-element)
(backward-sexp)
(setq content (buffer-substring-no-properties start (point)))
(nxml-up-element)
content))
(defun parse-row-co... | 1,180 | Common Lisp | .l | 40 | 25 | 65 | 0.653846 | epeld/class-files | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 94e3f8a9cdd1617acd79d8f43e821ba6d813351d8363a0309ed5bd5aa863164f | 32,284 | [
-1
] |
32,299 | standing-speed-diff-cube.lisp | tobbelobb_standing-speed-diff-cube/standing-speed-diff-cube.lisp | (defun first-round (l h lh e f mid &optional (temp 190))
(let* ((w (* 2 h))
(r (* 2 (+ l w)))
(skirt 10)
(lw (* e 6)))
(values
`((m107) ; Fan off
(m104 :s ,temp) ; Set hot end temp
(g28)
(g92 :x 0 :y 0 :z 0 :e 0) ; Prep nozzle
(g1 :z 5 :f 1000) ; Lift no... | 9,052 | Common Lisp | .lisp | 189 | 35.079365 | 118 | 0.402373 | tobbelobb/standing-speed-diff-cube | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 9fbeaab4a5de94b3835ebe74107ac24766a625ddefa02b64e9d80d697d85d654 | 32,299 | [
-1
] |
32,316 | xet1.lisp | aaron-lebo_lisp-engine/xet1.lisp | (in-package :xet)
(require :cl-opengl)
(require :pngload)
(require :sdl2)
(defparameter *db-path* "comanche.db")
(defparameter *create-chunk-radius* 10)
(defparameter *render-chunk-radius* 10)
(defparameter *delete-chunk-radius* 14)
(defparameter *render-sign-radius* 4)
(defvar *window*)
(defvar *online*)
(defun loa... | 5,719 | Common Lisp | .lisp | 137 | 29.927007 | 129 | 0.541487 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 1acaea400a2e9361941c0a36584fe5c1e26602e4e6b8130740f45460f67797c0 | 32,316 | [
-1
] |
32,317 | xet.lisp | aaron-lebo_lisp-engine/xet.lisp | (in-package :xet)
(require :cl-opengl)
(require :pngload)
(require :sdl2)
(defparameter *rgb* #(0.5 0.5 0.5))
(defvar *window*)
(defclass program ()
((id :initarg :id)))
(defun read-file (path)
(with-open-file (stream path)
(let ((str (make-string (file-length stream))))
(read-sequence str stream)
... | 3,305 | Common Lisp | .lisp | 79 | 35.063291 | 92 | 0.622236 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 2287fcf648aa718d19c584d4b5446b7d2a0377d1515bedc2cb2eedb80777d2e9 | 32,317 | [
-1
] |
32,318 | xet.asd | aaron-lebo_lisp-engine/xet.asd | (asdf:defsystem #:xet
:description "Describe xet here"
:author "Your Name <your.name@example.com>"
:license "Specify license here"
:depends-on (#:cl-opengl
#:pngload
#:sdl2)
:serial t
:components ((:file "package")
(:file "xet")))
| 288 | Common Lisp | .asd | 10 | 22.1 | 45 | 0.582734 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 97f3bf9fc10b2946340da824537a4836db75622522f2f3d15e61af7e12e8ebbe | 32,318 | [
-1
] |
32,322 | triangle_vertex.glsl | aaron-lebo_lisp-engine/shaders/triangle_vertex.glsl | #version 330 core
layout(location = 0) in vec3 xyz;
void main() {
gl_Position.xyz = xyz;
gl_Position.w = 1.0;
} | 121 | Common Lisp | .l | 6 | 17.666667 | 33 | 0.657895 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 2cf07f5c72590404f755e20681ab979c7d31f38e9728df826849cabc8245a58b | 32,322 | [
-1
] |
32,323 | block_vertex.glsl | aaron-lebo_lisp-engine/shaders/block_vertex.glsl | #version 120
uniform mat4 matrix;
uniform vec3 camera;
uniform float fog_distance;
uniform int ortho;
attribute vec4 position;
attribute vec3 normal;
attribute vec4 uv;
varying vec2 fragment_uv;
varying float fragment_ao;
varying float fragment_light;
varying float fog_factor;
varying float fog_height;
varying float... | 1,017 | Common Lisp | .l | 34 | 26.058824 | 79 | 0.667689 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 38198e405b88520279d909494ab1d9eda373240580f0ac93b9ade1d60ccd7a0d | 32,323 | [
-1
] |
32,324 | block_fragment.glsl | aaron-lebo_lisp-engine/shaders/block_fragment.glsl | #version 120
uniform sampler2D sampler;
uniform sampler2D sky_sampler;
uniform float timer;
uniform float daylight;
uniform int ortho;
varying vec2 fragment_uv;
varying float fragment_ao;
varying float fragment_light;
varying float fog_factor;
varying float fog_height;
varying float diffuse;
const float pi = 3.14159... | 1,180 | Common Lisp | .l | 35 | 30.085714 | 75 | 0.652936 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 417e72a90df35ac1f19d4f6304b9b40a6a4052c7600b1dbe3c66caa32e811dcc | 32,324 | [
-1
] |
32,325 | sky_vertex.glsl | aaron-lebo_lisp-engine/shaders/sky_vertex.glsl | #version 120
uniform mat4 matrix;
attribute vec4 position;
attribute vec3 normal;
attribute vec2 uv;
varying vec2 fragment_uv;
void main() {
gl_Position = matrix * position;
fragment_uv = uv;
}
| 206 | Common Lisp | .l | 10 | 18.4 | 36 | 0.765625 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | a98ca20f8f4158c058f70c11af323295b34265b30735b6d6dbe2e0e0e1046dcc | 32,325 | [
-1
] |
32,326 | line_fragment.glsl | aaron-lebo_lisp-engine/shaders/line_fragment.glsl | #version 120
void main() {
gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
}
| 75 | Common Lisp | .l | 4 | 16.5 | 44 | 0.585714 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | b4e57136aa2784e31665907f2e948053a276284d6c503ce382795a91db7e7e42 | 32,326 | [
-1
] |
32,327 | line_vertex.glsl | aaron-lebo_lisp-engine/shaders/line_vertex.glsl | #version 120
uniform mat4 matrix;
attribute vec4 position;
void main() {
gl_Position = matrix * position;
}
| 115 | Common Lisp | .l | 6 | 17 | 36 | 0.754717 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 63717dbd4e13bc8c827e094fa9f1060fbfaf59a8a2b57cd2854fe17e76447fe1 | 32,327 | [
-1
] |
32,328 | text_vertex.glsl | aaron-lebo_lisp-engine/shaders/text_vertex.glsl | #version 120
uniform mat4 matrix;
attribute vec4 position;
attribute vec2 uv;
varying vec2 fragment_uv;
void main() {
gl_Position = matrix * position;
fragment_uv = uv;
}
| 183 | Common Lisp | .l | 9 | 18 | 36 | 0.752941 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 9a053a18edab6e050d835a2d44f8c74d2bdbfa17260f5eedb8b2ebfab9db33e4 | 32,328 | [
-1
] |
32,329 | triangle_fragment.glsl | aaron-lebo_lisp-engine/shaders/triangle_fragment.glsl | #version 330 core
uniform vec3 color;
out vec3 colr;
void main() {
colr = color;
}
| 89 | Common Lisp | .l | 6 | 12.833333 | 19 | 0.716049 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 28a25029059550b6efa2777e84ee3612ba0239e82b344e69ab4852ee7874cd42 | 32,329 | [
-1
] |
32,330 | text_fragment.glsl | aaron-lebo_lisp-engine/shaders/text_fragment.glsl | #version 120
uniform sampler2D sampler;
uniform bool is_sign;
varying vec2 fragment_uv;
void main() {
vec4 color = texture2D(sampler, fragment_uv);
if (is_sign) {
if (color == vec4(1.0)) {
discard;
}
}
else {
color.a = max(color.a, 0.4);
}
gl_FragColor = co... | 327 | Common Lisp | .l | 16 | 15.5 | 49 | 0.581169 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 7ab942990d5b5efc5f5ef70ef7181ceee5e97c6410757a955ecf399f23fde62a | 32,330 | [
-1
] |
32,331 | sky_fragment.glsl | aaron-lebo_lisp-engine/shaders/sky_fragment.glsl | #version 120
uniform sampler2D sampler;
uniform float timer;
varying vec2 fragment_uv;
void main() {
vec2 uv = vec2(timer, fragment_uv.t);
gl_FragColor = texture2D(sampler, uv);
}
| 191 | Common Lisp | .l | 8 | 21.5 | 42 | 0.744444 | aaron-lebo/lisp-engine | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 47d6239efa9ea6940de593e64467c75c5a26ec2f6dc281e0286851f30950ba63 | 32,331 | [
-1
] |
32,346 | svg.lisp | jfjhh_curvy-wurvy/src/svg.lisp | ;;;;
;;;; SVG output language.
;;;; Alex Striff.
;;;;
(in-package #:parametric)
(defparameter *debug-stream* *standard-output*)
(defparameter *out-width* 1920)
(defparameter *out-height* 1080)
(defparameter *svg-indent* 4)
(defparameter *svg-depth* *svg-indent*)
(defparameter *svg-spaces* "")
(defparameter *text-s... | 4,795 | Common Lisp | .lisp | 119 | 35.487395 | 103 | 0.6103 | jfjhh/curvy-wurvy | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 654d58e1272ce1f3ab1d83831b93ef9a57953f3895c9e2f89565490b111df6e5 | 32,346 | [
-1
] |
32,347 | packages.lisp | jfjhh_curvy-wurvy/src/packages.lisp | ;;;;
;;;; Parametric package definitions.
;;;; Alex Striff.
;;;;
(defpackage #:parametric
(:use #:cl #:asdf #:alexandria))
| 127 | Common Lisp | .lisp | 6 | 19.5 | 36 | 0.647059 | jfjhh/curvy-wurvy | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | b30f276e04c332ac0c2e8107f759f7c610b8c8a0da62debc25a238179edd01a0 | 32,347 | [
-1
] |
32,348 | parametric.asd | jfjhh_curvy-wurvy/parametric.asd | ;;;;
;;;; The Parametric system definition.
;;;; Alex Striff.
;;;;
(defsystem "parametric"
:description "Parametric: A parametric curve exploration tool."
:version "0.0.1"
:author "Alex Striff"
:licence "MIT License"
:depends-on ("alexandria")
:components ((:file "src/packages")
(:file "src/... | 422 | Common Lisp | .asd | 13 | 28.076923 | 65 | 0.636364 | jfjhh/curvy-wurvy | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:39 AM (Europe/Amsterdam) | 67a9cbfc2b9ae8f9f50c4f0f3300d85d3ea298d31254c846232d9259414f3b8c | 32,348 | [
-1
] |
32,366 | 1.hola-mundo.lisp | MoiRouhs_lisp/1.hola-mundo.lisp | (format t "Hola mundo desde format") ; Permite imprimir variables sin tener que concatenarlas
(print "Hola mundo desde print") ; Imprime en consola sin salto de linea
(write "Hola mundo desde write") ; Imprimer cadenas de texto entre comillas dobles en consola sin salto de linea
(write-line "Hola mundo") ; Imprime cade... | 363 | Common Lisp | .lisp | 4 | 90 | 112 | 0.783333 | MoiRouhs/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:47 AM (Europe/Amsterdam) | 0679ba94fa99bdad6193acc2f26f5631a913d47480ae1812121efda1beec87d7 | 32,366 | [
-1
] |
32,367 | 3.decisiones.lisp | MoiRouhs_lisp/3.decisiones.lisp | (defun comparar (a b)
(if (> a b)
(write-line (concatenate 'string "A es mayor " (write-to-string a)))
(write-line (concatenate 'string "B es mayor " (write-to-string b)))
)
)
(comparar 12 26)
(defun comvarios (a b)
(cond
((= a b) (write "Son iguales"))
((> a b) (write (concatenate 'string "A es ... | 551 | Common Lisp | .lisp | 21 | 23.380952 | 77 | 0.608696 | MoiRouhs/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:47 AM (Europe/Amsterdam) | 21b336b8151e84f98174c4406ae832617c459f46d3d8f1f42787fdfed8838ec2 | 32,367 | [
-1
] |
32,368 | 4.ciclos.lisp | MoiRouhs_lisp/4.ciclos.lisp | (setq a 0) ; Se inicializa una variable en cero.
(loop ; Se inicializa el loop
(setq a (incf a 1)) ; Incrementea (incf) a en uno cada vez que se repite el ciclo.
(write a) ; Se muestra en consola el valor de la variable a
(terpri) ; Se haceun salto de linea
(when (= a 7) (return a)) ; Si a es igual a 7 se ... | 1,399 | Common Lisp | .lisp | 21 | 63.952381 | 196 | 0.701091 | MoiRouhs/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:47 AM (Europe/Amsterdam) | 758d22d75417a453d391f4369dfc97a37de2c76c411a0394548ac9ac24f24aaa | 32,368 | [
-1
] |
32,369 | 5.funciones.lisp | MoiRouhs_lisp/5.funciones.lisp | ; FUNCIONES
(defun saludar (nombre) ; defun define la funcion, seguido del nombre y entre parentesis los parametros.
(concatenate 'String "Hola " nombre)
; Este es el cuerpo de la funcion donde ejecuta el codigo, las funcones en lisp devuelven el ultimo valor definido.
)
(write-line (saludar "Andres"))
;FUNCION... | 1,919 | Common Lisp | .lisp | 30 | 61.833333 | 295 | 0.765708 | MoiRouhs/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:47 AM (Europe/Amsterdam) | a30a6c81cc6e173e8c933f543b10aa8bdd042935b15843f79ad0d0032fb373d8 | 32,369 | [
-1
] |
32,370 | 2.variables.lisp | MoiRouhs_lisp/2.variables.lisp | (defvar x "defvar") ; Variable global
(setq y "setq") ; Especifica el tipo de variable
(write-line x)
(write-line y)
(let ((g "let") (e "let2")) ; Variables locales.
(format t "esta es el valor de g: ~g y e: ~e" g e)
)
(defconstant PI 3.141592) ; Variables constantes que nunca cambian.
(print PI)
| 301 | Common Lisp | .lisp | 9 | 32.111111 | 67 | 0.687285 | MoiRouhs/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:47 AM (Europe/Amsterdam) | e6f2b1c75342010696c3a36583912c33490d185b6942efe8548e4da1aab6a651 | 32,370 | [
-1
] |
32,392 | list.lisp | spartakos87_Lists_in_Common_Lisp/list.lisp | ; Sum ,multiple,count list
(defun sum (lst )
(eval (cons '+ lst))
)
(defun multi (lst)
(eval (cons '* lst))
)
(defun count-lst (lst &optional (s 0))
(if (cdr lst)
(count-lst (cdr lst) (+ s 1))
(+ s 1)
)
)
(defun add-elem (lst &optional (a 1) ( temp '()))
(if (cdr lst)
... | 3,615 | Common Lisp | .lisp | 108 | 27.759259 | 87 | 0.542566 | spartakos87/Lists_in_Common_Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:47 AM (Europe/Amsterdam) | 8e497e96f8fc604ceb5a704e45c30346f3f1624fbb59333e622b9aa018935ad8 | 32,392 | [
-1
] |
32,409 | atomics.lisp | fch_LispTools/lib/tools/atomics/atomics.lisp | ; Some tools to handle lists even more efficiently
; Takes predicate and returns list of items satisfying it
(defun those (p)
(lambda (x)
(if (funcall p x) (list x))))
; Enable currying of parameters, so
; f: A_1 x ... x A_n -> B
; becomes
; f': A_1 -> (A_2 -> (...(A_n -> B)...))
(defun curry-par... | 544 | Common Lisp | .lisp | 17 | 28.823529 | 58 | 0.568138 | fch/LispTools | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 0a53c9a9c8c531ddc32e0e51f43d6bbc4ad8b82e7c53a180c1d0c1e4edae24ed | 32,409 | [
-1
] |
32,410 | physics_calculator.lisp | fch_LispTools/lib/tools/physics_calculator/physics_calculator.lisp | ; Simple calculator for MKSA-units
; Since every physical quantity can be written as
; Q * m^a * kg^b * s^c * A^d
; with a real number Q and integers a to d,
; we can represent this concept as a list
; (Q a b c d).
; ------ BASIC ARITHMETIC ------
(defun *u (a b)
(cons (* (car a) (car b))
(mapcar #'+ ... | 2,144 | Common Lisp | .lisp | 58 | 33.034483 | 57 | 0.425243 | fch/LispTools | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 6d1a285edce3ffe1e39ebb3a37ca88d015fefd972f3e83eab9cbd3c0960292d2 | 32,410 | [
-1
] |
32,428 | 10_Primos.lisp | vitormmatos_lispHiragiEx/10_Primos.lisp | (defun divs (n c d)
(if (> c n)
d (divs n (+ c 1)
(if (= (mod n c) 0)
(+ d 1) d)
)
)
)
(defun primo (n)
(if (= (divs n 1 0) 2)
T
NIL
)
)
(defun primos (n &optional (c 2))
(if (< n 1)
nil
(if (primo c)
(progn (print c)
(primos (- n 1) (+ c 1)
)
)
... | 455 | Common Lisp | .lisp | 28 | 12.428571 | 74 | 0.481043 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 49b04f227edc9ad5e484c02a35772f819a8c93bb15d09ab152f2b52b9dcde224 | 32,428 | [
-1
] |
32,429 | 5_Contar.lisp | vitormmatos_lispHiragiEx/5_Contar.lisp | (defun contar (fim)
(if (> fim 3)
(contar (- fim 3))
nil
)
(print fim)
)
(print "Esse programa conta de 3 em 3 até o número especificado")
(print "Digite o número: ")
(defvar num (read))
(contar num)
| 218 | Common Lisp | .lisp | 11 | 17.181818 | 65 | 0.64532 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 7bb630aa2f5689023fa7f26aa8b5462aca4fd3075665f0c693489f186632237d | 32,429 | [
-1
] |
32,430 | 6_ContarEmPassos.lisp | vitormmatos_lispHiragiEx/6_ContarEmPassos.lisp | (defun contar (inicio fim soma)
(print inicio)
(if (<= (+ inicio soma) fim)
(contar (+ inicio soma) fim soma)
nil
)
)
(print "Digite o numero inicial: ")
(defvar inicio (read))
(print "Digite o número de incremento: ")
(defvar passo (read))
(print "Digite o numero final: ")
(defvar fim (read))
(contar i... | 337 | Common Lisp | .lisp | 14 | 22 | 42 | 0.680124 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 92a5745531206115a0c1852e8d583ebfe1480b2763f1b6d34462c831e01f945e | 32,430 | [
-1
] |
32,431 | 3_SomaMult.lisp | vitormmatos_lispHiragiEx/3_SomaMult.lisp | (defun somaMult (num1 num2 num3)
(format t "~%A soma dos números ~d e ~d" num2 num3)
(if(/= num1 (+ num2 num3))
(format t " não")
)
(format t " é igual a ~d" num1)
)
(print "Digite o primeiro número: ")
(setq num1 (read))
(print "Digite o segundo número: ")
(setq num2 (read))
(print "Digite o terceiro núme... | 378 | Common Lisp | .lisp | 14 | 24.642857 | 53 | 0.655462 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 8008b9ade9f549cb7edbf99766ceffb10449a0f5c1c370c76ea29cf6765a8e27 | 32,431 | [
-1
] |
32,432 | 9_Compara.lisp | vitormmatos_lispHiragiEx/9_Compara.lisp | (defun compara (a b)
(if(> a b)
(format t "~%~d é maior que ~d" a b)
(if(< a b)
(format t "~%~d é menor que ~d" a b)
(format t "~%~d é igual a ~d" a b)
)
)
)
(print "Digite o primeiro valor: ")
(defvar num1 (read))
(print "Digite o segundo valor: ")
(defvar num2 (read))
(compara num1 num2... | 325 | Common Lisp | .lisp | 14 | 19.785714 | 42 | 0.563934 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | e3b0f06c7769f0998d7f2baad43246dca570280a3bf37afd773defb184b21718 | 32,432 | [
-1
] |
32,433 | 7_Fatorial.lisp | vitormmatos_lispHiragiEx/7_Fatorial.lisp | (defun fatorial (n &optional (intermediario 1))
(if (= n 1)
(return-from fatorial intermediario))
(fatorial (1- n) (* n intermediario))
)
(print "Digite um número para ver seu fatorial:")
(setq num (read))
(format t "~%O fatorial de ~d é ~d" num (fatorial num))
| 274 | Common Lisp | .lisp | 8 | 31.75 | 55 | 0.679389 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 498bd8182843ec7144fbe46921393b8fe45dbc7880a5256192d377eba95898e9 | 32,433 | [
-1
] |
32,434 | 1_Dias.lisp | vitormmatos_lispHiragiEx/1_Dias.lisp | (defun dias (anos)
(format t "~%~d anos equivalem a ~d dias" anos (* anos 365))
)
(print "Este programa calcula a quantidade de dias.")
(print "Digite a quantidade de anos: ")
(setq anos (read))
(dias anos)
| 210 | Common Lisp | .lisp | 7 | 28.571429 | 62 | 0.693069 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | f2b4b43adc26ca5da0209124f227aaa010da59d1e4d48d9671e3dd0098cc16ca | 32,434 | [
-1
] |
32,435 | 4_Contrario.lisp | vitormmatos_lispHiragiEx/4_Contrario.lisp | (defun contrario (palavra)
(format t (subseq palavra (- (length palavra) 1) (length palavra)))
(if (> (length palavra) 1)
(contrario (subseq palavra 0 (- (length palavra) 1)))
)
)
(print "Digite uma palavra: ")
(defvar palavra (string (read)))
(format t "~%O contrario de ~s é " palavra)
(contrario palavra)
| 320 | Common Lisp | .lisp | 10 | 29.9 | 69 | 0.676375 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 4826b9713c1f93a652bfe0509ab510a5a6edcaede7d2c1ac77d329f8824cb8b5 | 32,435 | [
-1
] |
32,436 | 8_Fibonacci.lisp | vitormmatos_lispHiragiEx/8_Fibonacci.lisp | (defun fibonacci(n)
(cond
((eq n 1) 0)
((eq n 2) 1)
((+ (fibonacci (- n 1))
(fibonacci (- n 2))))
)
)
(print "Este programa calcula o valor de fibonacci de um termo N")
(print "Digite N: ")
(setq num (read))
(format t "~%O termo ~dº de fibonacci é ~d" num (fibonacci num))
| 296 | Common Lisp | .lisp | 12 | 21.75 | 66 | 0.597865 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | e4fa78f8cfe77f7f672da66bc339b02ff76c245e2ddd80885751bd65dc7f7f39 | 32,436 | [
-1
] |
32,437 | 2_Salario.lisp | vitormmatos_lispHiragiEx/2_Salario.lisp | (defun converteSalario (salario)
(format t "~%R$~,2f equivale a ~,2f dólares" salario (/ salario 3.25))
(format t "~%R$~,2f equivale a ~,2f salários mínimos" salario (/ salario 937))
)
(print "Digite um salário: ")
(setq salario (read))
(converteSalario salario)
| 272 | Common Lisp | .lisp | 7 | 36.571429 | 80 | 0.7 | vitormmatos/lispHiragiEx | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 9cb7413c022d11cf9e34c3188c3bff33fda54aa96ac1ad583b478c0572595072 | 32,437 | [
-1
] |
32,463 | app.lisp | miscoined_miscoined/app.lisp | (ql:quickload :miscoined)
(defpackage miscoined.app
(:use :cl)
(:import-from :lack.builder
:builder)
(:import-from :ppcre
:scan)
(:import-from :miscoined.web
:*web*)
(:import-from :miscoined.config
:config
:productionp
... | 842 | Common Lisp | .lisp | 33 | 18.454545 | 88 | 0.546468 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 84689b75b56d865840987e2a5a81392a78de7f0e65e262df1801b7666d3c4d64 | 32,463 | [
-1
] |
32,464 | run.lisp | miscoined_miscoined/run.lisp | ;;;; Simple script to load the package and run server
(in-package :miscoined)
(ql:quickload :miscoined)
(miscoined:start)
| 124 | Common Lisp | .lisp | 4 | 29.5 | 53 | 0.779661 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 0609c9d0f78630929fd51e95740497f6c61563efc329a2fde7cc4f37093ebb30 | 32,464 | [
-1
] |
32,465 | main.lisp | miscoined_miscoined/src/main.lisp | (in-package :cl-user)
(defpackage miscoined
(:use :cl)
(:import-from :miscoined.config
:config)
(:import-from :clack
:clackup)
(:export :start
:stop))
(in-package :miscoined)
(defvar *appfile-path*
(asdf:system-relative-pathname :miscoined #P"app.lisp"))
(defvar *h... | 740 | Common Lisp | .lisp | 26 | 23.269231 | 66 | 0.632394 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | bc82cfa17ce15142e5d35c6b8025d7f983e6aa093c9663de89dfc83026b26e6d | 32,465 | [
-1
] |
32,466 | view.lisp | miscoined_miscoined/src/view.lisp | (in-package :cl-user)
(defpackage miscoined.view
(:use :cl)
(:import-from :miscoined.config
:*template-directory*)
(:import-from :caveman2
:*response*
:response-headers)
(:import-from :djula
:add-template-directory
:compile-template... | 1,264 | Common Lisp | .lisp | 37 | 26.189189 | 79 | 0.62326 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | f3f616e7b943b9e6d2143a868e0db8efb6356b4fdca3cc8f95f421b2d80fc3b5 | 32,466 | [
-1
] |
32,467 | config.lisp | miscoined_miscoined/src/config.lisp | (in-package :cl-user)
(defpackage miscoined.config
(:use :cl)
(:import-from :envy
:config-env-var
:defconfig)
(:export :config
:*application-root*
:*static-directory*
:*template-directory*
:appenv
:developmentp
:prod... | 1,099 | Common Lisp | .lisp | 34 | 27.5 | 87 | 0.658768 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 40fe10724e6100e0bb005d5457973cf3193f26136b80a127582654b319f61e09 | 32,467 | [
-1
] |
32,468 | web.lisp | miscoined_miscoined/src/web.lisp | (in-package :cl-user)
(defpackage miscoined.web
(:use :cl
:caveman2
:miscoined.config
:miscoined.view)
(:export :*web*))
(in-package :miscoined.web)
;; for @route annotation
(syntax:use-syntax :annot)
;;
;; Application
(defclass <web> (<app>) ())
(defvar *web* (make-instance '<web>))
(cle... | 571 | Common Lisp | .lisp | 24 | 21.083333 | 62 | 0.661111 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 65faa6148b6431351eb5eb5d86376d52b2550db8d037e74cec43a5a1403d5211 | 32,468 | [
-1
] |
32,469 | miscoined.asd | miscoined_miscoined/miscoined.asd | (defsystem "miscoined"
:version "0.1.0"
:author "Kelly Stewart"
:license ""
:depends-on ("clack"
"lack"
"caveman2"
"envy"
"cl-ppcre"
"uiop"
;; HTML Template
"djula")
:components ((:module "src"
... | 616 | Common Lisp | .asd | 20 | 19.7 | 61 | 0.444631 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 8064b1e59d95b69b640de053fac208103c266fabafd99af841ddf8eaf00e72b5 | 32,469 | [
-1
] |
32,477 | index.html | miscoined_miscoined/templates/index.html | {% extends "layouts/default.html" %}
{% block title %}{% endblock %}
{% block content %}
<main class="landing">
<h1>Kelly Stewar<span class="swatches">t</span></h1>
<nav>
<a href="mailto:stewart.g.kelly@gmail.com">
<i class="fa fa-envelope" title="Email"></i> stewart.g.kelly@gmail.com
</a... | 567 | Common Lisp | .l | 16 | 30.4375 | 83 | 0.595628 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | aa817cb088a84a11037305e7c1dfb3fbe64a3ecf2f97367f0d597f417d33f0af | 32,477 | [
-1
] |
32,478 | default.html | miscoined_miscoined/templates/layouts/default.html | <!DOCTYPE html>
<meta charset="utf-8" />
<title>Kelly Stewart{% block title %}{% endblock %}</title>
<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Cabin:400,700" />
<link rel="stylesheet" href="/css/main.css" />
<link rel="stylesheet" href="/css/cabin.css" />
<link rel="stylesheet" href="/css/buk... | 440 | Common Lisp | .l | 9 | 47.888889 | 86 | 0.700696 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | c815c35d0116b4f44eb8aa1e5cd5bac517f03d219543a48910da36af469ab81f | 32,478 | [
-1
] |
32,479 | 404.html | miscoined_miscoined/templates/_errors/404.html | <!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>404 NOT FOUND</title>
<style type="text/css">
html {
height: 100%;
}
body {
height: 100%;
font-family: 'Myriad Pro', Calibri, Helvetica, Arial, sans-serif;
background-color: #DFDFDF;
}
#main {
display: table;
width: 100%;
height: 100%;
}
... | 683 | Common Lisp | .l | 42 | 13.761905 | 67 | 0.638365 | miscoined/miscoined | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | f9f7b922143c3e5c8c4eb95e53bf2fe7ca20ae3e45f06d218aa3776cf5c2ea74 | 32,479 | [
-1
] |
32,494 | LogicResolustion.lisp | animeshjn_resolution-theorem-prover/LogicResolustion.lisp | ;Animesh Jain
(defun resolution(lc) ;lc is list of all clauses to be considered
;if empty list then no contradiction
(cond ((null lc) (print "No contradiction (Empty clauses)") (return-from resolution t)))
(setf remainder lc) ;initialize remaining clauses to be considered to all
(loop for current_clause in lc ... | 4,716 | Common Lisp | .lisp | 92 | 40.967391 | 135 | 0.575244 | animeshjn/resolution-theorem-prover | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | af5cfd881742de2ebb680c618e04d90a1886e28497cf6d293a0172f18de66dfc | 32,494 | [
-1
] |
32,497 | LogicResolustion.lib | animeshjn_resolution-theorem-prover/LogicResolustion.lib | #0Y_ #0Y |CHARSET|::|UTF-8|
(|SYSTEM|::|C-DEFUN| '|COMMON-LISP-USER|::|RESOLUTION|
(|SYSTEM|::|LAMBDA-LIST-TO-SIGNATURE| '(|COMMON-LISP-USER|::|LC|)))
(|SYSTEM|::|C-DEFUN| '|COMMON-LISP-USER|::|RESOLVE_EACH|
(|SYSTEM|::|LAMBDA-LIST-TO-SIGNATURE|
'(|COMMON-LISP-USER|::|CURRENT_CLAUSE| |COMMON-LISP-USER|::|REMAINING|... | 515 | Common Lisp | .l | 9 | 55.222222 | 72 | 0.658103 | animeshjn/resolution-theorem-prover | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | 6a816d0113c19fd50925d37d836919bd9321d31684328688a41311b7399a0ae0 | 32,497 | [
-1
] |
32,498 | LogicResolustion.fas | animeshjn_resolution-theorem-prover/LogicResolustion.fas | (|SYSTEM|::|VERSION| '(20080430.))
#0Y_ #0Y |CHARSET|::|UTF-8|
#Y(#:|1 54 (DEFUN RESOLUTION (LC) ...)-1|
#20Y(00 00 00 00 00 00 00 00 20 01 DA 2F 01 DA DC 32 9C C5 19 01)
(|COMMON-LISP-USER|::|RESOLUTION| |SYSTEM|::|REMOVE-OLD-DEFINITIONS|
#Y(|COMMON-LISP-USER|::|RESOLUTION|
#207Y(00 00 00 00 01 00 00 ... | 6,365 | Common Lisp | .l | 111 | 48.198198 | 83 | 0.544771 | animeshjn/resolution-theorem-prover | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:55 AM (Europe/Amsterdam) | d865c6bf84712e5d9ca063c5c9e19219b97bf102b89744de7567ffd99c7694cd | 32,498 | [
-1
] |
32,513 | wumpus.lisp | alexdijk_Lisp/wumpus.lisp | (load "/home/alexd/Documents/portacle/projects/dotgen.lisp")
(defparameter *congestion-city-nodes* nil)
(defparameter *congestion-city-edges* nil)
(defparameter *visited-nodes* nil)
(defparameter *node-num* 30)
(defparameter *edge-num* 45)
(defparameter *worm-num* 3)
(defparameter *cop-odds* 15)
(defun random-node (... | 7,043 | Common Lisp | .lisp | 165 | 29.309091 | 81 | 0.505623 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | 75948f8178e158d7c60867fdd958bab389d9219853d402ef1ed2a72df172e637 | 32,513 | [
-1
] |
32,514 | machikoro.lisp | alexdijk_Lisp/machikoro.lisp | ; simulation of the machi koro game
(defun throw-dice (n)
(if (eql n 1)
(1+ (random 6))
(+ (1+ (random 6)) (1+ (random 6)))))
(defun prodrnd ()
(loop for i from 1 to 100
do (format t "~D " (throw-dice 2))))
| 238 | Common Lisp | .lisp | 8 | 24.875 | 46 | 0.546256 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | 282a430679162034420fe90c0fa0b7b79a790a94dac13639134ae12a16484b63 | 32,514 | [
-1
] |
32,515 | mcclim-ex1.lisp | alexdijk_Lisp/mcclim-ex1.lisp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; McCLIM example (https://github.com/mcclim/mcclim
;;
;; Running:
;; 1. (ql:quickload "mcclim")
;; 2. load, run:
;; (app:app-main)
;;
(in-package :common-lisp-user)
(defpackage "APP"
(:use :clim :clim-lisp)
(:export "APP-MAIN"))
(in-packag... | 950 | Common Lisp | .lisp | 28 | 31.785714 | 80 | 0.66048 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | b7cfd73ac29ac369aac99d3e58f7696b18a714a937441dc383fa6758d0aec1cf | 32,515 | [
-1
] |
32,516 | gmn.lisp | alexdijk_Lisp/gmn.lisp | (defparameter *small* 1)
(defparameter *big* 100)
(defun guess-my-number ()
(ash (+ *small* *big*) -1))
(defun smaller ()
(setf *big* (1- (guess-my-number)))
(guess-my-number))
(defun bigger ()
(setf *small* (1+ (guess-my-number)))
(guess-my-number))
(defun start-over ()
(setf *small* 1)
(setf *big* 1... | 345 | Common Lisp | .lisp | 14 | 22.214286 | 39 | 0.629969 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | 4e5e0429e70a6dcc486b4f2692b30b4601edda28341f2988b3a8d5fa8dc2c791 | 32,516 | [
431753,
433657,
448214
] |
32,517 | towers.lisp | alexdijk_Lisp/towers.lisp | ;;
;; solution to tower of hanoi problem with variable number of disks
;;
(defparameter *peg-rack* '((peg-a ())
(peg-b ())
(peg-c ())))
(defun fill-rack (n)
(loop as i from n downto 1
do (push i (cadr (assoc 'peg-a *peg-rack*)))))
(defparameter *nm* 0)
... | 1,068 | Common Lisp | .lisp | 35 | 24.942857 | 74 | 0.552195 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | 79f7d710fb7c36585dc8258bad6532d779c034aa9a64dc5bb67e675fb53ebb32 | 32,517 | [
-1
] |
32,518 | lol-adv.lisp | alexdijk_Lisp/lol-adv.lisp | ;; Description of the wizards world
(defparameter *nodes* '((living-room (you are in the living room. a wizard is snoring loudly on the couch.))
(garden (you are in the garden. there is a well in front of you.))
(field (you are in a beautifull field. there are cows grazing. it is bordered by ... | 3,911 | Common Lisp | .lisp | 88 | 34.659091 | 108 | 0.56771 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | bd015fccd860e98cc53be7582c5a7986b1696e38becb36b69876e1960f19dbed | 32,518 | [
-1
] |
32,519 | dotgen.lisp | alexdijk_Lisp/dotgen.lisp | (defun dot-name (exp)
(substitute-if #\_ (complement #'alphanumericp) (prin1-to-string exp)))
(defparameter *max-label-length* 30)
(defun dot-label (exp)
(if exp
(let ((s (write-to-string exp :pretty nil)))
(if (> (length s) *max-label-length*)
(concatenate 'string (subseq s 0 (- *max-la... | 2,326 | Common Lisp | .lisp | 72 | 22.583333 | 77 | 0.484605 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | cc04271e3980048dd5efebaa58d03f0c2f7bfc231ac9c036d41b1781d34860fb | 32,519 | [
-1
] |
32,520 | exp.lisp | alexdijk_Lisp/exp.lisp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; A system to calculate the top and x1 and x2 of a
;; quadratic equation
;;
(defun axDiscr (a b c)
(- (expt b 2) (* 4 a c)))
(defun axX1X2 (a b c)
(let ((D (axDiscr a b c)))
(cond ((< D 0) (print "no solutions"))
((= D 0) (let ((x (/ b (* 2 a))))
(... | 710 | Common Lisp | .lisp | 22 | 28.318182 | 63 | 0.408759 | alexdijk/Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | f3eaa8e4169980f8afdc2f11275cf302486c35a34ba91782ff143e8ec9ca3ab3 | 32,520 | [
-1
] |
32,545 | 2lab.lisp | FreshHead_lisp_labs/2lab.lisp | (defun composition(a b)
"b must be integer"
(cond ((= b 1) a)
(t (+ a (composition a (- b 1) ))) ;(print (+ a (composition a (- b 1) ))))
)
)
;(trace composition)
(setq a 83.4)
(setq b 72)
(setq result (composition a b))
(format t "~%Result of composition ~F and ~D is ~F " a b result)
(with-open-file (stream... | 386 | Common Lisp | .lisp | 14 | 25.714286 | 77 | 0.633152 | FreshHead/lisp_labs | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | e7f34319940e255c641974d57678fcea4eab39a270c5ff74815e73e5b73c12ec | 32,545 | [
-1
] |
32,546 | 1lab.lisp | FreshHead_lisp_labs/1lab.lisp | (defun UF1 (x)
"UF1(x) = 2sin(x) + cos(2x)"
(+ (sin x) (cos (* 2 x)))
)
(defun UF2 (x)
"UF2(x) = cos^2(x + π / 4 )"
(expt (cos (+ (/ 3.14 4) x)) 2)
)
(format t "UF1(x) = ~F~%UF2(x) = ~F" (UF1 10) (UF2 10) )
(setq UFR (list (UF1 10) (UF2 10)))
(terpri)
(write "The list is ")
(write UFR)
(setq X1 (reverse UFR))... | 550 | Common Lisp | .lisp | 25 | 20.56 | 56 | 0.586873 | FreshHead/lisp_labs | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | 975482254c568201665377e6f664080e42fdde42bab1f9a270abf51a957048e8 | 32,546 | [
-1
] |
32,547 | 3lab.lisp | FreshHead_lisp_labs/3lab.lisp | (defun composition(a b)
"b must be integer"
(setq result 0)
(loop for i from 1 to b
do (setq result (+ result a))
)
(return-from composition result)
)
(defstruct city
x
y
)
(defun get_shortest_distance_between_three(first second third)
(cond ( (< (distance_between_two first second) (distance_between_two fir... | 1,419 | Common Lisp | .lisp | 44 | 30.568182 | 116 | 0.720351 | FreshHead/lisp_labs | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | fc22f03bc514ae9273777731502dbf84fb4b4faf25156ec1353ad87df7dc05f1 | 32,547 | [
-1
] |
32,566 | cl-statistics.lisp | croeder_lisp-stats-hunter/cl-statistics.lisp |
;;; Statistical functions in Common Lisp. Version 1.04 Feb 24, 2005
;;;
;;; This code is copyright (c) 2000, 2001, 2002, 2005 by Larry Hunter
;;; (Larry.Hunter@ucdenver.edu) except where otherwise noted.
;;; Thanks to Paul Cohen for the original CLASP package. Thanks also to bug
;;; reports from Rob St. Am... | 74,178 | Common Lisp | .lisp | 1,555 | 38.450804 | 102 | 0.573022 | croeder/lisp-stats-hunter | 0 | 0 | 0 | LGPL-2.1 | 9/19/2024, 11:43:03 AM (Europe/Amsterdam) | 9d3b10dc9a8b1ad36f2123fb3ab84678d6924e05a9340629cfb77aa55f01a065 | 32,566 | [
23989,
135861
] |
32,583 | hello-world.lisp | vinikira_cl-training/hello-world.lisp | "hello world"
(format t "hello world")
(defun hello-world ()
(format t "Hello, World"))
(hello-world)
| 109 | Common Lisp | .lisp | 5 | 19.4 | 30 | 0.683168 | vinikira/cl-training | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 28aa5d1608bab876d686a1e15f9f98a77ebc0a9c03c45de92d3c28ba2ffbf2bb | 32,583 | [
-1
] |
32,600 | package.lisp | mkrauss_lazy-list/package.lisp | (in-package :cl-user)
(defpackage :com.matthewkrauss.lazy-list
(:nicknames :lazy-list)
(:use :common-lisp))
(in-package :com.matthewkrauss.lazy-list)
(dolist (package '(:lazy-list/core
:lazy-list/sequence))
(do-external-symbols (symbol package)
(import symbol)
(export symbol)))
| 315 | Common Lisp | .lisp | 10 | 26.9 | 41 | 0.68543 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 32779c36dd046396069ef4d5ca559421c77e92dd7c6bc70d31323413ebd7d0ee | 32,600 | [
-1
] |
32,601 | package.lisp | mkrauss_lazy-list/test/package.lisp | (in-package :cl-user)
(defpackage :com.matthewkrauss.lazy-list/test
(:nicknames :lazy-list/test)
(:use :cl :parachute :lazy-list))
| 136 | Common Lisp | .lisp | 4 | 31.75 | 45 | 0.732824 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 64866bd61afaa0b089bf3e45f9f9ed36bff82aae44f0b7c40e2343577ce6b1c3 | 32,601 | [
-1
] |
32,602 | sequence.lisp | mkrauss_lazy-list/test/sequence.lisp | (in-package :com.matthewkrauss.lazy-list/test)
(define-test sequence
:serial nil)
(define-test series
:parent sequence :serial nil
(is equal '(1 2 3) (materialize (take 3 (series 1 1))))
(is equal '(3 7 11) (materialize (take 3 (series 3 4))))
(is equal '(0 1 2) (materialize (series-to 3 0 1)))
(is equal ... | 2,999 | Common Lisp | .lisp | 73 | 29.479452 | 74 | 0.466941 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | b6d2f33ba3eb1546bca72faf07f1368984f4675935339aa42f04f44b9516e284 | 32,602 | [
-1
] |
32,603 | core.lisp | mkrauss_lazy-list/test/core.lisp | (in-package :com.matthewkrauss.lazy-list/test)
(defun subject () (lcons 1 #'1+))
(define-test core :serial nil)
(define-test lcons
:parent core :serial nil
(of-type lcons (make-instance 'lcons :value 1 :fn #'1+))
(of-type lcons (lcons 1 #'1+))
(of-type lcons (lcons* 1 (lambda (x fn) (lcons* (1+ x) fn)))))
... | 927 | Common Lisp | .lisp | 29 | 27.758621 | 64 | 0.615991 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | fe481182942753821c5e77690b494a2da16a3973cfb63a36a3e5ffb502672051 | 32,603 | [
-1
] |
32,604 | lmapcar.lisp | mkrauss_lazy-list/sequence/lmapcar.lisp | (in-package :com.matthewkrauss.lazy-list/sequence)
(defun lmapcar (fn &rest lists)
"Map over a lazy list."
(if (some #'null lists) nil
(lcons* (apply fn (mapcar #'lcar lists))
(lambda (_x _fn)
(apply #'lmapcar fn (mapcar #'lcdr lists))))))
| 281 | Common Lisp | .lisp | 7 | 33.285714 | 62 | 0.59707 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 0d15cd73a333d9661943d769c230a5a07eb4635bf7e14ba36603f7987ef62610 | 32,604 | [
-1
] |
32,605 | package.lisp | mkrauss_lazy-list/sequence/package.lisp | (in-package :cl-user)
(defpackage :com.matthewkrauss.lazy-list/sequence
(:nicknames :lazy-list/sequence)
(:use :common-lisp :lazy-list/core)
(:export series
series-to
series-through
lmapcar
lfilter
lappend
lmappend
lcross))
| 308 | Common Lisp | .lisp | 12 | 17.666667 | 49 | 0.59322 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | d5b852d6aa819792da03b36c3adac799b7a1126474e65c0724ad0516e1a52b8d | 32,605 | [
-1
] |
32,606 | lfilter.lisp | mkrauss_lazy-list/sequence/lfilter.lisp | (in-package :com.matthewkrauss.lazy-list/sequence)
(defgeneric lfilter (predicate list))
(defmethod lfilter (predicate (list null)) nil)
(defmethod lfilter (predicate (list lcons))
(let ((value (lcar list)))
(if (funcall predicate value)
(lcons* value (lambda (x fn)
(lfilter pre... | 385 | Common Lisp | .lisp | 9 | 36.333333 | 57 | 0.662198 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | ccd302d799fe2512c7419b7d23b4761953ebdbf7a7b4de12d08bc92b21eeb371 | 32,606 | [
-1
] |
32,607 | lcross.lisp | mkrauss_lazy-list/sequence/lcross.lisp | (in-package :com.matthewkrauss.lazy-list/sequence)
(defun lcross (fn &rest lists)
"Map over multiple lists, combining each element of each list."
(when lists (lcross-impl fn (car lists) (cdr lists))))
(defgeneric lcross-impl (fn list lists))
(defmethod lcross-impl (fn (list null) lists)
nil)
(defmethod lcross... | 613 | Common Lisp | .lisp | 15 | 33.6 | 65 | 0.634064 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | dfb1f47524c8f50dc3045394d691548fb7496d493045f459f4da6eb42b20ca26 | 32,607 | [
-1
] |
32,608 | lmappend.lisp | mkrauss_lazy-list/sequence/lmappend.lisp | (in-package :com.matthewkrauss.lazy-list/sequence)
(defun lmappend (fn &rest lists)
"Map over a lazy list appending results."
(if (some #'null lists) nil
(let ((first-list-result (apply fn (mapcar #'lcar lists))))
(lcons* (lcar first-list-result)
(lambda (_value _self)
... | 471 | Common Lisp | .lisp | 10 | 35.4 | 76 | 0.558696 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 7c82bad89278d0838a0aba7288cbfc4123204dceae1178a6d0a7a2519a572a07 | 32,608 | [
-1
] |
32,609 | series.lisp | mkrauss_lazy-list/sequence/series.lisp | (in-package :com.matthewkrauss.lazy-list/sequence)
(defun series (initial increment)
"Return a lazy series from INITIAL, adding INCREMENT, indefinitely."
(lcons initial (lambda (x) (+ x increment))))
(defun series-to (limit initial increment)
(take-while (lambda (x) (< x limit))
(series initial in... | 461 | Common Lisp | .lisp | 10 | 41.2 | 70 | 0.694196 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | aa64b341dece0804d94c8862e2262f9ceaab05f3e0af482c3c218e5ffc12a763 | 32,609 | [
-1
] |
32,610 | lappend.lisp | mkrauss_lazy-list/sequence/lappend.lisp | (in-package :com.matthewkrauss.lazy-list/sequence)
(defun lappend (&rest lists)
"Appending multiple lazy lists."
(when lists (apply #'lappend-impl lists)))
(defgeneric lappend-impl (list &rest lists))
(defmethod lappend-impl ((list null) &rest lists)
(apply #'lappend lists))
(defmethod lappend-impl ((list con... | 608 | Common Lisp | .lisp | 15 | 35.6 | 55 | 0.668367 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 68404e7b1e9428d32fca89a59bc6a0db55a173138c8808f4608a87e660705285 | 32,610 | [
-1
] |
32,611 | package.lisp | mkrauss_lazy-list/core/package.lisp | (in-package :cl-user)
(defpackage :com.matthewkrauss.lazy-list/core
(:nicknames :lazy-list/core)
(:use :common-lisp)
(:export lcons
lcons*
lcar
lcdr
take
take-while
materialize))
| 252 | Common Lisp | .lisp | 11 | 15.272727 | 45 | 0.5625 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | e18c7626aa34165a297ac901eb9e10ebe7ad1a3c345af0255c4dd2b87d0d36f3 | 32,611 | [
-1
] |
32,612 | lcons.lisp | mkrauss_lazy-list/core/lcons.lisp | (in-package :com.matthewkrauss.lazy-list/core)
(defclass lcons ()
((value :initarg :value)
(fn :initarg :fn))
(:documentation "Lazy evaluating list-forming cons cell. LCAR
returns a recorded value, while LCDR returns NIL or another LCONS
where the recorded value is a function transformation of this
one.")... | 841 | Common Lisp | .lisp | 19 | 40.894737 | 73 | 0.735043 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 2141fac8a26f556eb3160c65fb67d47b99b7e2758c32b902b6f95ecab32a0bcc | 32,612 | [
-1
] |
32,613 | materialize.lisp | mkrauss_lazy-list/core/materialize.lisp | (in-package :com.matthewkrauss.lazy-list/core)
(defgeneric materialize (finite-lazy-item)
(:documentation "Return a fully materialized representation of a
lazy item. For instance, if FINITE-LAZY-ITEM is a lazy list, fully
evaluate the and return an actual list. If FINITE-LAZY-ITEM is not
materializable this wi... | 670 | Common Lisp | .lisp | 14 | 45.142857 | 68 | 0.736923 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 9c65d4ef75bb0fc8f2378f2bb7cd52cd0fb2c7f3c06c7f54255faa308a29050b | 32,613 | [
-1
] |
32,614 | print-object.lisp | mkrauss_lazy-list/core/print-object.lisp | (in-package :com.matthewkrauss.lazy-list/core)
(defmethod print-object ((cell lcons) out)
(print-unreadable-object (cell out :type t)
(format out "~s" (materialize cell))))
| 180 | Common Lisp | .lisp | 4 | 42.25 | 46 | 0.725714 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | c4ec52b310205a7cceb068be844cac4603e2932d3f6a20985b0ee6418d8b9038 | 32,614 | [
-1
] |
32,615 | take-while.lisp | mkrauss_lazy-list/core/take-while.lisp | (in-package :com.matthewkrauss.lazy-list/core)
(defgeneric take-while (predicate sequence))
(defmethod take-while (predicate (sequence null)) nil)
(defmethod take-while (predicate (sequence lcons))
(let ((value (lcar sequence)))
(when (funcall predicate value)
(lcons* value
(lambda (x fn)
... | 379 | Common Lisp | .lisp | 9 | 36.111111 | 59 | 0.678474 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 4ece9e75e68861a92b3bb3bb3260973cf61b33647789e77f15a822e0ef00f07f | 32,615 | [
-1
] |
32,616 | lcar.lisp | mkrauss_lazy-list/core/lcar.lisp | (in-package :com.matthewkrauss.lazy-list/core)
(defgeneric lcar (lazy-cons)
(:documentation "The car of a lazy cons cell."))
(defmethod lcar ((cell lcons))
(slot-value cell 'value))
(defmethod lcar ((cell cons))
(car cell))
| 233 | Common Lisp | .lisp | 7 | 31 | 50 | 0.721973 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 6105698ea09a1d30b6dc513dbfaab5ebf220508a6442576567c87f1e25d46c13 | 32,616 | [
-1
] |
32,617 | take.lisp | mkrauss_lazy-list/core/take.lisp | (in-package :com.matthewkrauss.lazy-list/core)
(defgeneric take (number sequence))
(defmethod take (number (sequence null)) nil)
(defmethod take ((number (eql 0)) sequence) nil)
(defmethod take (number (sequence lcons))
(lcons* (lcar sequence)
(lambda (x fn)
(take (1- number) (lcdr sequence)... | 325 | Common Lisp | .lisp | 8 | 36.125 | 49 | 0.683706 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 736ecacea1b0d9f963401ffe290774085a5cde3b7be03bed84fe31b2ce0e2b01 | 32,617 | [
-1
] |
32,618 | lcdr.lisp | mkrauss_lazy-list/core/lcdr.lisp | (in-package :com.matthewkrauss.lazy-list/core)
(defgeneric lcdr (lazy-cons)
(:documentation "The cdr of a lazy cons cell."))
(defmethod lcdr ((cell lcons))
(with-slots (value fn) cell
(funcall fn value fn)))
(defmethod lcdr ((cell cons))
(cdr cell))
| 263 | Common Lisp | .lisp | 8 | 30.25 | 50 | 0.710317 | mkrauss/lazy-list | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:11 AM (Europe/Amsterdam) | 31fc4b02186d05714ead785af3da0775a1654b5d5108c1f209ce0b4bdde0633f | 32,618 | [
-1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.