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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
38,905 | alists.lisp | davd33_simple-cv-with-lisp/src/alists.lisp | (in-package #:alists)
(defparameter A '((:a (:b . 11) (:c . "hello"))
(:d . 32))
"Example json to test the current package's functions.")
(defun merge-acons (value alist &rest tree-path)
"Merge in a tree-structured alist 'value' following the 'tree-path'."
(labels ((contains-field? (alist f)
... | 1,801 | Common Lisp | .lisp | 41 | 30.439024 | 76 | 0.505125 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | b0bbdf650472994354a399fe5ad80fa5ec11de78fc19b91a1adcbc2726978b5b | 38,905 | [
-1
] |
38,906 | dev.mocks.lisp | davd33_simple-cv-with-lisp/src/dev.mocks.lisp | (in-package #:dev.mocks)
(defparameter basic-cv "{
\"title\": \"'( :david :rueda )\",
\"sub-title\": \"Open your Mind and Technologies\",
\"image-description\": \"me in an image\",
\"contact\": {
\"mail\": \"davd33@gmail.com\",
\"linkedin\": \"https://www.linkedin.com/in/davd33-rueda/\",
\"github\"... | 6,997 | Common Lisp | .lisp | 190 | 28.9 | 311 | 0.54258 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | b0e90da84f66cacc60a70fdf8c679f0ee3f6b64c4a32a28adf07107c9f82e1be | 38,906 | [
-1
] |
38,907 | jsons.lisp | davd33_simple-cv-with-lisp/src/jsons.lisp | (in-package #:jsons)
(defun get-in (json &rest fields)
(loop for f in fields
for res = (cdr (assoc f json)) then (cdr (assoc f res))
finally (return res)))
(defun type-compatible-p (json class-symbol &optional array-p)
"Return T if JSON is compatible with CLASS.
If ARRAY-P is T then checks TYPE-COMPATIB... | 2,981 | Common Lisp | .lisp | 56 | 33.464286 | 105 | 0.439083 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 70285157f5823123b6effa7d0b5757b4aae79d09f9c5e7b51b0c9c3fa76cbab0 | 38,907 | [
-1
] |
38,908 | data.lisp | davd33_simple-cv-with-lisp/src/data.lisp | (in-package #:data)
(defun group-by (sequence &key (kv-pair #'identity))
"Group all elements of sequence, using kv-pair in order to get
the list (key value) of an element."
(reduce (lambda (grouped elt)
(destructuring-bind (key val) (funcall kv-pair elt)
(setf (gethash key grouped) (app... | 510 | Common Lisp | .lisp | 11 | 34.727273 | 71 | 0.574297 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | a11665f92be89548a35cf56a3bb39b1a0ec7446ad7da785413f91f03b618a90a | 38,908 | [
-1
] |
38,909 | lang.en.lisp | davd33_simple-cv-with-lisp/src/lang.en.lisp | (:cv.title
"'( :david :rueda )"
:cv.sub-title
"Open your Mind and Technologies"
:cv.pic.img.alt
"me in an image"
:my-experience-with-lisp
('("I have been introduced to functional programming end of 2018 as our team was
given the task to develop a new internal front-end application with React.js. We
... | 4,327 | Common Lisp | .lisp | 101 | 38.009901 | 288 | 0.704169 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 2c7eb43971c718e32ceee5319d4b29785c27267f94e96fcf4a37d8464daba899 | 38,909 | [
-1
] |
38,910 | dto.lisp | davd33_simple-cv-with-lisp/src/dto.lisp | (in-package #:dto)
(defclass contact-dto ()
((mail :initarg :mail
:accessor mail
:type string
:documentation "Mail address.")
(linkedin :initarg :linkedin
:accessor linkedin
:type string
:documentation "Linkedin URL.")
(github :initarg :github
... | 4,341 | Common Lisp | .lisp | 111 | 27.882883 | 109 | 0.585839 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | d484e2f5e2b7fc27038fc9ba587d49a950305d7786de19087657bb577f7492c7 | 38,910 | [
-1
] |
38,911 | dao.lisp | davd33_simple-cv-with-lisp/src/dao.lisp | (in-package #:dao)
(defparameter *connection* nil)
(defun connect (&optional (db-name "be_it") (username "postgres") (password "helloworld"))
(when (null *connection*)
(setf *connection*
(mito:connect-toplevel :postgres
:database-name db-name
... | 6,474 | Common Lisp | .lisp | 168 | 31.434524 | 105 | 0.619662 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 2a5b6af8c4eee3b2ea526ab0e80cab6e8a46983a8c1993fcf8ac725cb23115c1 | 38,911 | [
-1
] |
38,912 | services.lisp | davd33_simple-cv-with-lisp/src/services.lisp | (in-package #:services)
(defmacro defpost (name (&rest args) (&rest json-args) doc &body body)
"Creates a function that contains code to validate that every JSON-ARGS
given to a function call is checked against the desired class.
The JSON-ARGS arguments shall be lists of two elements:
- the name of the variable
-... | 8,418 | Common Lisp | .lisp | 114 | 34.403509 | 147 | 0.34959 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | cedc146fdf106328a9637f03cce212a098677e0b0a965065d2a3cc1279b9a154 | 38,912 | [
-1
] |
38,913 | mop.lisp | davd33_simple-cv-with-lisp/src/mop.lisp | (in-package #:mop)
(defun find-class-slots (class-symbol)
"Return the list of slots for CLASS-SYMBOL."
(funcall (alexandria:compose #'(lambda (slots)
(mapcar #'(lambda (elt)
(closer-mop:slot-definition-name elt))
... | 4,899 | Common Lisp | .lisp | 84 | 36.77381 | 98 | 0.479933 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | f936e9b3ac38fd77889a681734e8da2a109d96b43ef278e1eb5cefbdd803dffe | 38,913 | [
-1
] |
38,914 | packages.lisp | davd33_simple-cv-with-lisp/src/packages.lisp | (defpackage #:alists
(:use #:cl #:alexandria)
(:export #:aconses
#:deep-acons
#:merge-acons))
(defpackage #:jsons
(:use #:cl)
(:export #:get-in
#:add-value
#:type-compatible-p))
(defpackage #:hm
(:use #:cl)
(:shadow #:get
#:reduce
#:first)
... | 2,935 | Common Lisp | .lisp | 133 | 14.774436 | 55 | 0.50986 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | e3958164839048a6c3e59fd7226f0aab38a7892ce5903151582c6b5313634665 | 38,914 | [
-1
] |
38,915 | pipe.lisp | davd33_simple-cv-with-lisp/src/pipe.lisp | (in-package #:pipe)
(defstruct delay (value nil) (fn nil))
(defmacro delay (&body body)
"A computation that can be executed later by FORCE."
`(make-delay :fn #'(lambda () ,@body)))
(defun force (x)
"Find the value of x, by computing if it is a delay."
(if (not (delay-p x))
x
(progn
(when ... | 2,155 | Common Lisp | .lisp | 61 | 29.491803 | 71 | 0.603647 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 56fea161a8076028e981f9840e81ee249bde8f86ce2b0aabe031647252688d02 | 38,915 | [
-1
] |
38,916 | jsons.lisp | davd33_simple-cv-with-lisp/tests/jsons.lisp | ;;; DEFINE SOME DTO CLASSES
(defpackage be-it/tests/jsons-dtos
(:use :cl :be-it)
(:export :acar
:color
:wheel))
(in-package :be-it/tests/jsons-dtos)
(defclass color ()
(r g b))
(defclass wheel ()
((radius :type integer)))
(defclass acar ()
((size :type integer)
(color :type color)
... | 2,561 | Common Lisp | .lisp | 53 | 44.698113 | 204 | 0.612335 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | ec67cec39f0d6c4000904aea59e67bec9b084e2134248ca05d414f3d106a0e8a | 38,916 | [
-1
] |
38,917 | api-handlers.lisp | davd33_simple-cv-with-lisp/tests/api-handlers.lisp | (defpackage be-it/tests/api-handlers
(:use :cl
:be-it
:api
:rove))
(in-package :be-it/tests/api-handlers)
(defparameter cv-json1 "{
\"title\": \"'( :david :rueda )\",
\"subTitle\": \"Open your Mind and Technologies\",
\"imageDescription\": \"me in an image\",
\"contact\": {
... | 7,863 | Common Lisp | .lisp | 177 | 33.20904 | 317 | 0.511198 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 18e4f17d325fd2b3ee6456b32efdb2e3a50d2f346d43a6174b0c54ea7979f88c | 38,917 | [
-1
] |
38,918 | be-it.asd | davd33_simple-cv-with-lisp/be-it.asd | (defsystem "be-it"
:version "0.1.0"
:author "David Rueda"
:license "GPLv3"
:serial t
:depends-on (#:spinneret
#:hunchentoot
#:snooze
#:dexador
#:cl-json
#:clack
#:fset
#:str
#:mito
... | 1,479 | Common Lisp | .asd | 49 | 17.795918 | 80 | 0.417075 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 1f88779e4dffe2ca0922d913323d8a5574531e1e8792b7446c25aad16833e56b | 38,918 | [
-1
] |
38,920 | deploy.sh | davd33_simple-cv-with-lisp/deploy.sh | #!/bin/bash
wkhtmltopdf ./src/my-cv.html ./src/resources/cv.david-rueda.pdf && \
cp -r ./src/resources /home/davd/linode/var/www/localhost/htdocs/
| 152 | Common Lisp | .l | 3 | 48 | 69 | 0.716216 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 6ee808e399fc602fbd3fb35a60dd298cbed5d2209b4af20c789b77e828e8d015 | 38,920 | [
-1
] |
38,930 | db-scratch.sql | davd33_simple-cv-with-lisp/src/db-scratch.sql | drop table contact;
drop table cv;
drop table work_experience;
drop table reading;
drop table paragraph_element;
select * from cv cv
join contact co on co.id=cv.contact_id
full outer join work_experience we on we.cv_id=cv.id
full outer join reading r on r.cv_id=cv.id
full outer join paragraph_element pe on pe.cv_id=cv... | 352 | Common Lisp | .l | 11 | 30.909091 | 54 | 0.8 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | eb7db74480646b7d343ad6cdb1e4a17283d23238626f2331ad406d1a602458e0 | 38,930 | [
-1
] |
38,933 | my-cv.html | davd33_simple-cv-with-lisp/src/my-cv.html | <!DOCTYPE html>
<html lang=en>
<head>
<meta charset=UTF-8>
<link rel=stylesheet
href=./resources/css/cv.css type=text/css>
<link rel=stylesheet
href=./resources/css/font-awesome.css
type=text/css>
<title>Davd Rueda</title>
</head>
<body>
<section class=contact>
<a class=contact-l... | 7,371 | Common Lisp | .l | 228 | 27.5 | 92 | 0.673529 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | b2bc05ec0f2c11005e646e0c726d6350811ade19530f41c1b432d9f34470de0f | 38,933 | [
-1
] |
38,939 | fa-light-300.svg | davd33_simple-cv-with-lisp/src/resources/webfonts/fa-light-300.svg | <?xml version="1.0" standalone="no"?>
<!--
Font Awesome Pro 5.10.2 by @fontawesome - https://fontawesome.com
License - https://fontawesome.com/license (Commercial License)
-->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg" xmln... | 2,066,646 | Common Lisp | .l | 10,593 | 193.312282 | 254 | 0.710969 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 4498cf735fe9c944b9e9b28a4906f09f6232968c232d6148a83fe0430d291ce5 | 38,939 | [
-1
] |
38,940 | fa-solid-900.svg | davd33_simple-cv-with-lisp/src/resources/webfonts/fa-solid-900.svg | <?xml version="1.0" standalone="no"?>
<!--
Font Awesome Pro 5.10.2 by @fontawesome - https://fontawesome.com
License - https://fontawesome.com/license (Commercial License)
-->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg" xmln... | 1,514,718 | Common Lisp | .l | 8,280 | 180.935024 | 254 | 0.709047 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | c19246b497aa4db336417c1e742b79267e1a1a2f416ec091b49af52df611a879 | 38,940 | [
-1
] |
38,941 | fa-regular-400.svg | davd33_simple-cv-with-lisp/src/resources/webfonts/fa-regular-400.svg | <?xml version="1.0" standalone="no"?>
<!--
Font Awesome Pro 5.10.2 by @fontawesome - https://fontawesome.com
License - https://fontawesome.com/license (Commercial License)
-->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg" xmln... | 1,856,861 | Common Lisp | .l | 9,726 | 189.064261 | 254 | 0.71146 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 72780435f327cb21a783eb5528db74c3ebebb2a32c60e72e987f79b227ac8a34 | 38,941 | [
-1
] |
38,958 | signal-generics.lisp | bpatrikm_cl-gtk-frank/signal-generics.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;Copyright (C) 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software Foundation, either version 3 of the License, or
;;(at your option)... | 1,468 | Common Lisp | .lisp | 39 | 35.487179 | 105 | 0.777305 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 2a91a2529a5fd526810010539d754f22cd239c89295f0537ab46f8a28fdc92bb | 38,958 | [
-1
] |
38,959 | builder.lisp | bpatrikm_cl-gtk-frank/builder.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 6,970 | Common Lisp | .lisp | 127 | 38.622047 | 129 | 0.522804 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | c99e3e61e12016e4b26f5f1cc82b34fe5b7d3a125706a13dbd6d0c1912cbad1b | 38,959 | [
-1
] |
38,960 | tree-layer.lisp | bpatrikm_cl-gtk-frank/tree-layer.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;Copyright (C) 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software Foundation, either version 3 of the License, or
;;(at your option)... | 3,759 | Common Lisp | .lisp | 54 | 66.166667 | 442 | 0.765998 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | f6e17efbde718031e9709ba80ad4560ff43553aa16bc10c755283df54213ef68 | 38,960 | [
-1
] |
38,961 | tree-viewer.lisp | bpatrikm_cl-gtk-frank/tree-viewer.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 6,472 | Common Lisp | .lisp | 105 | 54.190476 | 573 | 0.710209 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 50d1904079e5b1affa28253b51e4b9fd60b121e9fa97504c04ca8ad88b7830b3 | 38,961 | [
-1
] |
38,962 | content-holder.lisp | bpatrikm_cl-gtk-frank/content-holder.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 3,489 | Common Lisp | .lisp | 72 | 44.166667 | 105 | 0.733216 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 42ecc877ee9e558cac57c32804d7f6547b3f2179fa981a75886729a619c32d8c | 38,962 | [
-1
] |
38,963 | widgets.lisp | bpatrikm_cl-gtk-frank/widgets.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 11,855 | Common Lisp | .lisp | 205 | 44.95122 | 326 | 0.598208 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 6fa1c27ce1147817bfbc99e0da95154984c00359183e7254f19d0b8fe5469f2e | 38,963 | [
-1
] |
38,964 | tree-store-basic.lisp | bpatrikm_cl-gtk-frank/tree-store-basic.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 15,300 | Common Lisp | .lisp | 260 | 45.842308 | 357 | 0.612493 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | deb381a33e91293a3a214191027ed53ee4f356b6b104eaf267a80f52f36b497c | 38,964 | [
-1
] |
38,965 | packages.lisp | bpatrikm_cl-gtk-frank/packages.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 11,684 | Common Lisp | .lisp | 248 | 38.173387 | 215 | 0.688819 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | b399ee2278ee37f948f13b9b68ceccd334c445d34e6768aa520628e265ae0563 | 38,965 | [
-1
] |
38,966 | viewer-update-requests.lisp | bpatrikm_cl-gtk-frank/viewer-update-requests.lisp | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 2,619 | Common Lisp | .lisp | 48 | 49.854167 | 195 | 0.737814 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 5e47931caf8b67fd180be2b2b0f8a60daf6fff6e7339e838a2324388f3493dd1 | 38,966 | [
-1
] |
38,967 | cl-gtk-frank.asd | bpatrikm_cl-gtk-frank/cl-gtk-frank.asd | ;;cl-gtk-frank, an abstraction layer for Gtk in LISP
;;(based on a subset of code which was named cl-gtk-cv)
;;Copyright (C) 2012-2013, 2019 Patrik Magnusson
;;This program is free software: you can redistribute it and/or modify
;;it under the terms of the GNU General Public License as published by
;;the Free Software... | 1,238 | Common Lisp | .asd | 25 | 43.32 | 105 | 0.679074 | bpatrikm/cl-gtk-frank | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | d596a5d8f3b97ee1ac38203a93dfa5f42834b0ab87935b871e484e52f9c97280 | 38,967 | [
-1
] |
38,993 | leven.lisp | bitmappergit_lisp-work/leven.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 https://mozilla.org/MPL/2.0/.
(defvar *list* '("Harry Potter And The Half Blood Prince"
"Harry Potter And The Chamber Of Secrets"... | 3,131 | Common Lisp | .lisp | 87 | 27.83908 | 80 | 0.570434 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | e4efcde304437fccff97214b05afc6742d79aa038661c084e70880c14dfa7757 | 38,993 | [
-1
] |
38,994 | flatten.lisp | bitmappergit_lisp-work/flatten.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 https://mozilla.org/MPL/2.0/.
(defun flatten (list)
(if (some #'listp list)
(flatten (reduce
#'(lambda (a b)
... | 453 | Common Lisp | .lisp | 11 | 31.545455 | 70 | 0.544218 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 266e72bd8a1996fb7293049ff93f3e9f4fc3083d9c129e32a620d5a6ebeaba04 | 38,994 | [
-1
] |
38,995 | http.lisp | bitmappergit_lisp-work/http.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 https://mozilla.org/MPL/2.0/.
(in-package :cl)
(defpackage :http-client
(:use :common-lisp
:usocket)
(:export :request-http))
(in-pa... | 1,439 | Common Lisp | .lisp | 32 | 38.96875 | 83 | 0.642602 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | badab973c711e066a175aff48794d3471668b66c48a1d3bb49c0f5082a5a1cb4 | 38,995 | [
-1
] |
38,996 | add.lisp | bitmappergit_lisp-work/add.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 https://mozilla.org/MPL/2.0/.
(defun sum-of-integers (end &optional (current 0) (value 0))
(if (equal end current)
(+ current value)
... | 469 | Common Lisp | .lisp | 9 | 49.222222 | 70 | 0.68709 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 324d81f020c892464d0c9b9f6f2a9db623dbd0253a31bcbc88b8f4deb1b2be1c | 38,996 | [
-1
] |
38,997 | fac.lisp | bitmappergit_lisp-work/fac.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 https://mozilla.org/MPL/2.0/.
(defun fac (x &optional (y 1))
(if (equal x 1)
y
(fac (- x 1) (* y x))))
| 291 | Common Lisp | .lisp | 7 | 38.428571 | 70 | 0.64311 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | ae429cd729a335a1d5709a2d0d446ddef2da79db99f6305488600672b04348ec | 38,997 | [
-1
] |
38,998 | thread.lisp | bitmappergit_lisp-work/thread.lisp | ;; copyright is attributed to mveety (matthew veety)
(defmacro defthread (sym (&key (name "anonymous thread") (place nil)) &body body)
(if (eq place nil)
`(defun ,sym ()
(sb-thread:make-thread
(lambda ()
,@body)
:name ,name))
`(defun ,sym ()
(setf ,place ... | 450 | Common Lisp | .lisp | 13 | 23.153846 | 81 | 0.477064 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | c5858f527cab53fc14631b557e1e2a933c783b8075b7e879060933d4f4d51a07 | 38,998 | [
-1
] |
38,999 | macro.lisp | bitmappergit_lisp-work/macro.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 https://mozilla.org/MPL/2.0/.
(defmacro -> (begin &rest items)
(reduce #'(lambda (x y)
(reverse (cons x y)))
(mapcar #'r... | 897 | Common Lisp | .lisp | 29 | 22.517241 | 70 | 0.478513 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | b5895075ecf39b8420a990c5ce3a449da3a9220cd35538408b0b9bdfaa55ff2a | 38,999 | [
-1
] |
39,000 | fib.lisp | bitmappergit_lisp-work/fib.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 https://mozilla.org/MPL/2.0/.
(defun fib (n &optional (np 0) (y 0) (x 1))
(if (equal np n)
x
(fib n (+ np 1) x (+ y x))))
| 310 | Common Lisp | .lisp | 7 | 41.142857 | 70 | 0.63245 | bitmappergit/lisp-work | 0 | 0 | 0 | MPL-2.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 2f648688a42b1fe74d9b5923b03d5addf91abb7f5d39cd11040f71edfcce72b9 | 39,000 | [
-1
] |
39,024 | LMC.lisp | Cryosec_LMC/Lisp/LMC.lisp |
;;; Basic parser for assembly code
;;; LMC LOAD
(defun lmc-load (filename)
(let ((newmem (list-formatting (lmc-open filename))))
(let ((labelist (parse-labels newmem)))
(fillmem
(opcodes
(del-labels newmem labelist) labelist)))))
;;; LMC RUN
(defun lmc-run (filename in)
(exe... | 11,477 | Common Lisp | .lisp | 311 | 27.016077 | 79 | 0.520471 | Cryosec/LMC | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 1cf95655c3a3e1056dd39b298cb05f714ece187b60b6a3a7d6315ead8b5a0369 | 39,024 | [
-1
] |
39,026 | parser.pl | Cryosec_LMC/Prolog/parser.pl |
:- style_check(-singleton).
:- dynamic labelized/2.
lmc_load(File, NewCodes) :-
open(File, read, Str),
N is 0,
read_stuff(Str, N, L),
remove_blank(L, OpCodes),
get_machine_codes(OpCodes, Machine_Codes), !,
close(Str),
fill(Machine_Codes, NewCodes),
print(NewCodes).
fil... | 2,939 | Common Lisp | .l | 96 | 25.114583 | 56 | 0.560286 | Cryosec/LMC | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | e79467241b0c2476792bff1f113076a3f2f94ab68a89668e9d225c3af2f23af9 | 39,026 | [
-1
] |
39,027 | lmc.pl | Cryosec_LMC/Prolog/lmc.pl |
%%% lmc.pl
:- style_check(-singleton).
:- consult('parser.pl').
one_instruction(state(Acc, Pc, Mem, In, Out, Flag), NewState) :-
\+ length(Mem, 0),
exec_instruction(state(Acc, Pc, Mem, In, Out, Flag), NewState).
execution_loop(halted_state(Acc, Pc, Mem, In, Out, Flag), Out) :- !.
execution_loop... | 4,634 | Common Lisp | .l | 126 | 30.825397 | 69 | 0.571075 | Cryosec/LMC | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | ecc21a52cd663fbb4263831e7171ee39c64ebd730be9c87b4be226c8467b5624 | 39,027 | [
-1
] |
39,043 | cl-chip8.lisp | jasondemps1_cl-chip8/cl-chip8.lisp | ;;;; cl-chip8.lisp
(in-package #:cl-chip8)
(defparameter *opcode* nil)
;; Memory
(defparameter *Memory* (make-array '(4096) :element-type 'byte))
;; Registers
(defparameter *V* (make-array '(16) :element-type 'byte))
;;; Special Registers
;;; TODO - Force these to
(defparameter *I* 0)
(defparameter *PC* 0)
;;; G... | 6,338 | Common Lisp | .lisp | 200 | 26.64 | 147 | 0.562602 | jasondemps1/cl-chip8 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 9c1f2a59c26341cb590f0943c28e429f29e26b889256223eb610112b5d0e3db7 | 39,043 | [
-1
] |
39,044 | cl-chip8.asd | jasondemps1_cl-chip8/cl-chip8.asd | ;;;; cl-chip8.asd
(asdf:defsystem #:cl-chip8
:description "Describe cl-chip8 here"
:author "Jason Dempsey"
:license "Specify license here"
:version "0.0.1"
:serial t
:depends-on (#:sdl2)
:components ((:file "package")
(:file "cl-chip8")))
| 270 | Common Lisp | .asd | 10 | 23 | 39 | 0.637066 | jasondemps1/cl-chip8 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 4445be4f1a52ee280b0a8b8a63029221b627bb5a09c8d712d66c76a65fb48acb | 39,044 | [
-1
] |
39,062 | evolution.lisp | pk2codes_landoflisp/evolution.lisp | (defparameter *width* 100)
(defparameter *height* 60)
(defparameter *jungle* '(45 10 10 10))
(defparameter *plant-energy* 500)
(defparameter *reproduction-energy* 200)
(defparameter *plants* (make-hash-table :test #'equal))
(defparameter *energy-coeff* 100) ;; describes tanh function for food consumption efficiency
(de... | 6,684 | Common Lisp | .lisp | 187 | 31.68984 | 107 | 0.642614 | pk2codes/landoflisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | c36ce2d53b437c054a21f34687d4272942eb90d6953380774ecaf78dadc6db3b | 39,062 | [
-1
] |
39,063 | diceofdoom.lisp | pk2codes_landoflisp/diceofdoom.lisp | (defparameter *num-players* 2)
(defparameter *max-dice* 3)
(defparameter *board-size* 2)
(defparameter *board-hexnum* (* *board-size* *board-size*))
(defun board-array (lst)
(make-array *board-hexnum* :initial-contents lst))
(defun player-letter (n)
(code-char (+ 97 n)))
(defun gen-board ()
(board-array (loop... | 2,537 | Common Lisp | .lisp | 57 | 26.824561 | 101 | 0.441653 | pk2codes/landoflisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 38531eedf81b233d9caeb8cde108d94cd3e0e4ca2a1f9e54784c19ae33869d6b | 39,063 | [
-1
] |
39,064 | graph.lisp | pk2codes_landoflisp/graph.lisp | (defparameter *nodes* '((living-room (You are in the living room.
A beautiful woman is painting on the dining table.))
(hallway (You are in the hallway.
A small meadow bringing you in all rooms. ))
(citchen (You are in the kitchen.
the smell of backed vegetables makes you feel hungry.))
(sl... | 3,298 | Common Lisp | .lisp | 97 | 29.360825 | 99 | 0.642409 | pk2codes/landoflisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 95b87da317796c1bb6415f348a7a3bd953981d8e6945d859323776ee5df23c59 | 39,064 | [
-1
] |
39,065 | gtw.lisp | pk2codes_landoflisp/gtw.lisp | (load "graph.lisp")
(defparameter *congestion-city-nodes* nil)
(defparameter *congestion-city-edges* nil)
(defparameter *visited-nodes* nil)
(defparameter *visited-edges* nil)
(defparameter *node-num* 30) ;; locations
(defparameter *edge-num* 45) ;; roads
(defparameter *worm-num* 3) ;; worm teams
(defparameter *cop-o... | 6,535 | Common Lisp | .lisp | 184 | 30.652174 | 150 | 0.633286 | pk2codes/landoflisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 98b09673d7b9d1d09aefae1c9646394127f23c6ef3d0708590b08cbf397a882c | 39,065 | [
-1
] |
39,066 | wizardadventure.lisp | pk2codes_landoflisp/wizardadventure.lisp | (defparameter *nodes* '((living-room (You are in the living room.
A beautiful woman is painting on the dining table.))
(hallway (You are in the hallway.
A small meadow bringing you in all rooms. ))
(citchen (You are in the kitchen.
the smell of backed vegetables makes you feel hungry.))
(sl... | 3,838 | Common Lisp | .lisp | 98 | 34.387755 | 105 | 0.653237 | pk2codes/landoflisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | b756040e96f1bbb8bf963797dfe6fdbb8c3c7a90093ddab68a2b32ce36dcd6f0 | 39,066 | [
-1
] |
39,067 | orcbattle.lisp | pk2codes_landoflisp/orcbattle.lisp | (defparameter *player-health* nil)
(defparameter *player-agility* nil)
(defparameter *player-strength* nil)
(defparameter *monsters* nil)
(defparameter *monster-builders* nil)
(defparameter *monster-num* 12)
(defun randval (n)
(1+ (random (max 1 n))))
(defstruct monster (health (randval 10)))
(defmethod monster-sh... | 6,053 | Common Lisp | .lisp | 187 | 28.561497 | 86 | 0.62942 | pk2codes/landoflisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 0da28d88308a820921863e0761f8e6a2b6147d4e1f1c9ce69b6d805b5b5a4663 | 39,067 | [
-1
] |
39,089 | bbb-oe.asd | eric-gustafson_bbb-oe/bbb-oe.asd | ;;;; bbb-oe.asd
(asdf:defsystem #:bbb-oe
:description "Describe bbb-oe here"
:author "Your Name <your.name@example.com>"
:license "Specify license here"
:version "0.0.1"
:serial t
:components ((:file "package")
(:file "bbb-oe")))
| 259 | Common Lisp | .asd | 9 | 24.666667 | 45 | 0.634538 | eric-gustafson/bbb-oe | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | baac2fc997a60a1ad0cac9f880fc0410529a4d1c2e1d4b35b7e5dcf378d2e054 | 39,089 | [
-1
] |
39,090 | ccl.org | eric-gustafson_bbb-oe/ccl.org | #+title: BeagleBone Black - Open Embedded CCL Recipe Notes
These are internal notes to self.
* Objective
To bring up a clozure common lisp (ccl) image on the beaglebone
black. I don't think it's possible to do this with a standard
x-compile, like the other software since ccl bootstraps itself,
we need it ... | 1,485 | Common Lisp | .cl | 22 | 64.681818 | 115 | 0.653131 | eric-gustafson/bbb-oe | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | a267f275671eda4b54f78f6fee1b39369179b31d044d79ad3623ce5a1e947a58 | 39,090 | [
-1
] |
39,107 | is_list.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/is_list.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;; # File
;;;; is_list.lisp: function to detect if one component is a list or not
(load "is_variable.lisp")
(defun is_list (var)
(and
(listp var)
(not (is_va... | 339 | Common Lisp | .lisp | 14 | 21.357143 | 72 | 0.634375 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | f5b70753b7589b602f50af337483727accfa56773c0bb7f1f1c5d002b151b1b6 | 39,107 | [
-1
] |
39,108 | same_type.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/same_type.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;; # File
;;;; is_list.lisp: function to detect if one component is a list or not
(load "is_atom.lisp")
(load "is_list.lisp")
(load "is_variable.lisp")
(defun same_... | 542 | Common Lisp | .lisp | 18 | 27.277778 | 100 | 0.618497 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 3829a2bfcdd34d84454a21cf1004a4e610f23ddead8031fab5831af84187c05e | 39,108 | [
-1
] |
39,109 | is_equal.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/is_equal.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;; # File
;;;; contains.lisp: function to detect if one item is contained in another
(load "same_type.lisp")
(load "is_variable.lisp")
(load "eq_var.lisp")
(defun... | 434 | Common Lisp | .lisp | 14 | 28.357143 | 81 | 0.651332 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 6f71dad8a7c630d6922eb2f60fe31da5ca878aa575c64d9ebc864991bc12e700 | 39,109 | [
-1
] |
39,110 | contains.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/contains.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;; # File
;;;; contains.lisp: function to detect if one item is contained in another
;; Pseudocode
;; ==========
;;
;; CONTAINS(list element) {
;; if list is n... | 847 | Common Lisp | .lisp | 37 | 19.594595 | 75 | 0.543071 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 830721fb09d718fa1b53af8676e0c4fa793ce2d07e5a0f57571aaf4bb138e71e | 39,110 | [
-1
] |
39,111 | composition.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/composition.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'apply.lisp)
;;; 2. > (is_variable 1)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Lu... | 1,255 | Common Lisp | .lisp | 35 | 33.028571 | 112 | 0.695436 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 09a7cedce0cd909e7cc93d097fa7b2ae1db9a630051fae8055e6add42ca4fb04 | 39,111 | [
-1
] |
39,112 | is_atom.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/is_atom.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'is_atom.lisp)
;;; 2. > (is_atom 1)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Luis... | 695 | Common Lisp | .lisp | 23 | 28.26087 | 101 | 0.630792 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | ba384c2569be04bb53496923952d8830e9d5f7f8edce2eb4f980721d8fe86c29 | 39,112 | [
-1
] |
39,113 | apply_to_test.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/apply_to_test.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'apply.lisp)
;;; 2. > (is_variable 1)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Lu... | 2,909 | Common Lisp | .lisp | 91 | 28.351648 | 113 | 0.589964 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 016bfcbd7481fe5eb1764b48ff681baac74979f6a39ba480cfc53fb192f4f465 | 39,113 | [
-1
] |
39,114 | is_variable.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/is_variable.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'is_variable.lisp)
;;; 2. > (is_variable 1)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2... | 1,107 | Common Lisp | .lisp | 36 | 28.416667 | 141 | 0.527752 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 9eb7a0dfc9db4781d2a4cb302512da9a5992c4b270131383e0db717380608eb0 | 39,114 | [
-1
] |
39,115 | unification.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/unification.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Luis Blázquez, Samuel Gómez
;;;; # File
;;;;unification.l... | 1,731 | Common Lisp | .lisp | 57 | 27.368421 | 221 | 0.667071 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 585b25991b080100e85215abb374904a54e6b382ffd0d4610ed32d2970a2418c | 39,115 | [
-1
] |
39,116 | eq_var.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/eq_var.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;; # File
;;;; contains.lisp: function to detect if one item is contained in another
(load "value_of.lisp")
(load "type_of.lisp")
(defun eq_var (x y)
(when (and (e... | 543 | Common Lisp | .lisp | 21 | 23 | 75 | 0.595745 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 9ec56558ccc1538ac6b161d8199409d73dca4aa1d01608e6722fd0bce2bada3d | 39,116 | [
-1
] |
39,117 | get_item_index_in_list.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/get_item_index_in_list.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'apply.lisp)
;;; 2. > (is_variable 1)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Lu... | 641 | Common Lisp | .lisp | 23 | 25.913043 | 116 | 0.660163 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | f0d312210a4766c688d9f14aec57f893e17e644a5a77b6be90f57c5ad80ad052 | 39,117 | [
-1
] |
39,118 | apply_to.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/apply_to.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'apply_to.lisp)
;;; 2. > (is_variable 1)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019... | 2,118 | Common Lisp | .lisp | 53 | 37 | 130 | 0.570941 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 8365cbcd1e42176f5b0e68f46bcb0449e882bd77fe75a6af149fc166ade4abd1 | 39,118 | [
-1
] |
39,119 | unification_test.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/unification_test.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Luis Blázquez, Samuel Gómez
;;;; # File
;;;;unification.l... | 5,579 | Common Lisp | .lisp | 239 | 20.150628 | 221 | 0.620859 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | dc39d72e2cd94761f1a9a46068793e656af5b90c14a5641e97d59972d1e07666 | 39,119 | [
-1
] |
39,120 | eq_list.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/eq_list.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;; # File
;;;; contains.lisp: function to detect if one item is contained in another
;; Pseudocode
;; ==========
;;
;; EQ_LIST (list_x list_y) {
;;
;; if length(... | 1,608 | Common Lisp | .lisp | 48 | 30.291667 | 134 | 0.57411 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 0bb91b5b871250dfa741d7a013fba13a53aedde143ac5ac6b77bbc6e375c116d | 39,120 | [
-1
] |
39,121 | set_var.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/set_var.lisp | (defun set_var (var val)
(set var '(?))
(append var (val))
) | 65 | Common Lisp | .lisp | 4 | 14.25 | 25 | 0.564516 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | cdf4212d62ac9765858080db823481dbe29982e3abad4a1e9b5f44352c2fd5b3 | 39,121 | [
-1
] |
39,122 | load_files.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/load_files.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'is_atom.lisp)
;;; 2. > (load_files)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Lui... | 651 | Common Lisp | .lisp | 24 | 25.75 | 72 | 0.680129 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | cc4bd01115dc7fc9784b41f9479f68698cb4ff21963590db6a0ebe7021e12aa9 | 39,122 | [
-1
] |
39,123 | type_of.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/type_of.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;; # File
;;;; contains.lisp: function to detect if one item is contained in another
(load "is_variable.lisp")
(load "is_atom.lisp")
(defun type_of (x)
(when (is_v... | 421 | Common Lisp | .lisp | 14 | 27.5 | 75 | 0.651741 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 7d894c4490e63970c4155a06a1bc275e435eec3551558c39bca1c3f05915752c | 39,123 | [
-1
] |
39,124 | composition_test.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/composition_test.lisp | ;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*-
;;;
;;; # Title: Unification
;;;
;;; Implementation of the Unification Algorithm using LISP
;;;
;;; # Usage
;;; 1. > (load 'apply.lisp)
;;; 2. > (is_variable 1)
;;;
;;; # License
;;;
;;; Code from Paradigms of Artificial Intelligence Programming
;;; Copyright (c) 2019 Lu... | 2,153 | Common Lisp | .lisp | 90 | 21.211111 | 112 | 0.621807 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 9076959e868a8a131627dbeef538db2e833d6c0ebecb7922531e4440d22f235d | 39,124 | [
-1
] |
39,125 | test.lisp | luisblazquezm_gii-4-lost-in-stupid-parentheses/src/test.lisp |
(defun probar(arg1 arg2 expected_result given_result)
(if (equal expected_result given_result)
(format t "Arg1:~s~%Arg2:~s~%Returns: ~s~%Expected:~s~%~%Test SUPERADO~%"
arg1 arg2 given_result expected_result
)
(format t "Arg1:~s~%Arg2:~s~%Returns: ~s~%Expected:~s~%Test NO superado~%"
arg1 arg2 g... | 11,833 | Common Lisp | .lisp | 296 | 38.388514 | 235 | 0.31908 | luisblazquezm/gii-4-lost-in-stupid-parentheses | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:48 AM (Europe/Amsterdam) | 035aec2176f45a1aef592716c56237e3d2df972e92f032dcffd9cfd272b98216 | 39,125 | [
-1
] |
39,160 | lmc.lisp | 0Barzuln0_LMC2/lmc.lisp |
;;; VALIDAZIONI SULLO STATE
;;; Funzioni accessorie a is-valid-state/1
(defun is-valid-mem-value (n)
(and (numberp n)
(<= 0 n 999)))
;;; Un indice valido di cella di memoria e un valore valido per il pc
(defun is-valid-cell-value (n)
(and (numberp n)
(<= 0 n 99)))
(defun list-has-valid-values ... | 14,486 | Common Lisp | .lisp | 446 | 28.217489 | 77 | 0.65173 | 0Barzuln0/LMC2 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | ca8d27e51dc54930a1cf12041ec40e1f8c23409e516140686ff5aa5a5b250010 | 39,160 | [
-1
] |
39,163 | reverse.lmc | 0Barzuln0_LMC2/File di prova in assembly LMC/reverse.lmc | load inp // read the input
brz clean // if zero start printing
sta tmp // store the number in a temporary variable
lda sp // load the stack pointer
add stoop // add the "base" of the store opcode
sta inst1 // store the generated instruction in memory
... | 1,843 | Common Lisp | .l | 37 | 43.864865 | 81 | 0.611511 | 0Barzuln0/LMC2 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | 2114c5c8c5832ea878d1d4b7082be015fe67caf53e7ff058579bd1b1f2151ae3 | 39,163 | [
-1
] |
39,164 | exec.lmc | 0Barzuln0_LMC2/File di prova in assembly LMC/exec.lmc | first bra farAway // try this program with input 901 902 705 600 0 4 5 6 7 8 9 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0
dat 0... | 1,139 | Common Lisp | .l | 100 | 10.4 | 80 | 0.781731 | 0Barzuln0/LMC2 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | b45c610816a35d1181ef22e905435fca44925e3625fe3c31e7ad722847e7cf52 | 39,164 | [
-1
] |
39,165 | looping.lmc | 0Barzuln0_LMC2/File di prova in assembly LMC/looping.lmc | // Questo programma esegue due cicli innestati senza produrre nessun
// output alla fine. Ad ogni ciclo piu' interno stampa il valore
// dell'indice del ciclo interno (10000 valori di output totali)
lda zero //notare che questo assembly e' case-insensitive
sta i //e quindi riferirsi alla stessa etichetta in maiuscolo
L... | 525 | Common Lisp | .l | 27 | 18.481481 | 68 | 0.799599 | 0Barzuln0/LMC2 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | 3f58b6b1261edf321e4eeeb57f56f2af3ea6fb2761274c4c8096142fe03db8d8 | 39,165 | [
-1
] |
39,166 | prova.lmc | 0Barzuln0_LMC2/File di prova in assembly LMC/prova.lmc | first ADD 85 // blalbla
second SUB 84
//bene
hlt // fermaaaa
ouT
dat 999 //troppo! | 91 | Common Lisp | .l | 6 | 13.666667 | 23 | 0.674419 | 0Barzuln0/LMC2 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | 270c02474b8fae74fceab46aad56794fb595abf7184cb606a05463badacf1a71 | 39,166 | [
-1
] |
39,167 | multiplication.lmc | 0Barzuln0_LMC2/File di prova in assembly LMC/multiplication.lmc | // We perfom the multiplication of two numbers
// by using repeated addition
inp // get the first number
sta FIRST
inp // get the second number
LOOP brz END
sub ONE
sta SECOND
lda RESULT
add FIRST
sta RESULT
lda SECOND
bra LOOP
// print... | 565 | Common Lisp | .l | 22 | 20.045455 | 56 | 0.626394 | 0Barzuln0/LMC2 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | 8b637b00377a6900e9a359ca47c30ac5701800584983e99715288ba571275312 | 39,167 | [
-1
] |
39,182 | english_monograms.lisp | agentlans_secret-code/english_monograms.lisp | (("E" . 529117365)
("T" . 390965105)
("A" . 374061888)
("O" . 326627740)
("I" . 320410057)
("N" . 313720540)
("S" . 294300210)
("R" . 277000841)
("H" . 216768975)
("L" . 183996130)
("D" . 169330528)
("C" . 138416451)
("U" . 117295780)
("M" . 110504544)
("F" . 95422055)
("G" . 91258980)
("P" . 90376747)
("W" . 79843664)... | 455 | Common Lisp | .lisp | 26 | 16.461538 | 18 | 0.570093 | agentlans/secret-code | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | 717b0371a8cdb2b33e0d737c2e09930e2a71923a7b3428fe82e8ddc4abf32cb8 | 39,182 | [
-1
] |
39,183 | secret-code.lisp | agentlans_secret-code/secret-code.lisp | ;; secret-code : a Common Lisp package for making and breaking simple ciphers
;; Copyright (C) 2019 Alan Tseng
;; This program is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the L... | 8,256 | Common Lisp | .lisp | 224 | 33.549107 | 78 | 0.69025 | agentlans/secret-code | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | a9cd7032bd88f5d0c65c6d98104c0b82bf8ada6ab401dc90832d1933078da0d5 | 39,183 | [
-1
] |
39,201 | main.lisp | Fhoughton_index-search/src/main.lisp | (setf lparallel:*kernel* (lparallel:make-kernel 4))
(defun get-file (filename)
(with-open-file (stream filename)
(loop for line = (read-line stream nil)
while line
collect line)))
(defun search-for-words-simple (lines wordlist)
(declare (optimize (speed 3) (safety 0)) ;Add (debug 0) for even str... | 1,719 | Common Lisp | .lisp | 36 | 37.666667 | 134 | 0.605247 | Fhoughton/index-search | 0 | 0 | 0 | LGPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | eb974efed418584ae642341e967105c75c89d002bf0a84e93e80ed9e82128f48 | 39,201 | [
-1
] |
39,202 | index-search.asd | Fhoughton_index-search/index-search.asd | (defsystem "index-search"
:author "Fhoughton"
:license "LGPL-3.0"
:description "A multithreaded list search that provides power and speed."
:version "1.0.0"
;; Dependencies
:depends-on ("split-sequence"
"lparallel"
)
;; Project files / load order
:components (... | 486 | Common Lisp | .asd | 14 | 24 | 76 | 0.526652 | Fhoughton/index-search | 0 | 0 | 0 | LGPL-3.0 | 9/19/2024, 11:45:56 AM (Europe/Amsterdam) | fb44c4d1fc0e54724dafe4f62be3697295c68b2e3a72fb5b258a6e3144ffc32e | 39,202 | [
-1
] |
39,219 | helloworld.lisp | willow385_lisp-devel/helloworld.lisp | ;; Hello world program written in Common Lisp by Dante Falzone.
(defun hello()
(format t "Hello, world!~%"))
(hello)
| 122 | Common Lisp | .lisp | 4 | 28.25 | 63 | 0.700855 | willow385/lisp-devel | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 67a39c2afc0badd6e4996d176b410297c8bbe829ddd14869157287990e0e8219 | 39,219 | [
-1
] |
39,220 | cat.lisp | willow385_lisp-devel/cat.lisp | ;; Very rudimentary implementation of the Unix cat utility
(defun main ()
(if (eq *args* nil)
(loop for input-line = (read-line)
until (eq input-line :eof)
do (format t "~a~%" input-line))
(let ((in (open (car *args*) :if-does-not-exist :error)))
(when in
... | 465 | Common Lisp | .lisp | 12 | 28.333333 | 65 | 0.506637 | willow385/lisp-devel | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | a9f78194049ac264de01d5df5da8aaac8f77b869a07cf7895175a8618240623b | 39,220 | [
-1
] |
39,221 | fizzbuzz.lisp | willow385_lisp-devel/fizzbuzz.lisp | ;; Very simple FizzBuzz in Common Lisp
(loop for i from 1 to 100 do
(cond
((eq (mod i 15) 0) (format t "FizzBuzz~%"))
((eq (mod i 5) 0) (format t "Buzz~%"))
((eq (mod i 3) 0) (format t "Fizz~%"))
(t (format t "~D~%" i))))
| 276 | Common Lisp | .lisp | 7 | 33.285714 | 51 | 0.468401 | willow385/lisp-devel | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | b1588d51b7614443f33dde96cf9f364a8550c8bdf582d86f58f57dae530a2d53 | 39,221 | [
-1
] |
39,222 | greet.lisp | willow385_lisp-devel/greet.lisp | (defun main()
(format t "Hello! What's your name?~%> ")
(setq input (read-line))
(format t "Nice to meet you, ~a!~%" input))
(main)
| 145 | Common Lisp | .lisp | 5 | 25.4 | 47 | 0.582734 | willow385/lisp-devel | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 5dd013a0b89fab71cb529bc379570b4a5a983de7c5474481c80ccaf6321bba2b | 39,222 | [
-1
] |
39,242 | main.lisp | flaviobergamini_Trabalho-Lisp-workshop/main.lisp | (defun soma ()
(format t " ~% Insira o primeiro numero: ")
(setq a (read))
(format t " ~% Insira o segundo numero: ")
(setq b (read))
(format t " ~% Resultado = ~2d"( + a b))
)
(defun sub ()
(format t " ~% Insira o primeiro numero: ")
(setq a (read))
(format t " ~% Insira o s... | 1,640 | Common Lisp | .lisp | 48 | 29.25 | 74 | 0.420716 | flaviobergamini/Trabalho-Lisp-workshop | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | ae76ba0babdabb7416a9e2f77556cac48b84a757371a3702ec693a712eb4a8a3 | 39,242 | [
-1
] |
39,274 | globals.lisp | Akah_cl-pkmn/src/globals.lisp | ;;;; Globals
;; dirty global variables
(in-package #:pkmn)
(defparameter *state* :start-menu)
(defparameter *scale* 2)
(defparameter *width* (* 13 16 *scale*))
(defparameter *height* (* 11 16 *scale*))
(defparameter *title* "PKMN")
(defparameter *tile-size* (* *scale* 16))
(defparameter *x* 0)
(defparameter *y* 8)
(... | 855 | Common Lisp | .lisp | 29 | 28.413793 | 76 | 0.739078 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 0dcd3b4bc1245c740ad94618c278f33733c5581d17e46ecdb7aa939ffe1e910f | 39,274 | [
-1
] |
39,275 | pkmn.lisp | Akah_cl-pkmn/src/pkmn.lisp | ;;;; pkmn.lisp
(in-package #:pkmn)
;;; have both players parties and bags(inventory) as global
(defparameter *tackle* (make-move
:name "tackle"
:type 'normal
:pp-current 35
:pp-max 35
:accuracy 100
:power 40
:category 'physical
:effect (lambda ())))
(defparameter *test* (make-move
:na... | 1,436 | Common Lisp | .lisp | 67 | 16.80597 | 59 | 0.606907 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 73ade97dceccc95fc72bb6b7bc9ba60391f5343262c158a00075aa2461013d99 | 39,275 | [
-1
] |
39,276 | view-state.lisp | Akah_cl-pkmn/src/view-state.lisp | ;;; view-state
;; code related to game state management
(in-package #:pkmn)
(deftype state ()
"posible game states"
'(member
:start-menu
:overworld
:menu
:battle))
(defun statep (value)
"check whether value is of type state"
(typep value 'state))
(defun do-start-menu ()
(sb-thread:make-thr... | 568 | Common Lisp | .lisp | 23 | 21.347826 | 81 | 0.67963 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | b5c01f475eb8cda7e319b6087560083cd01c33e8a4d33e4e751520d3c3bac402 | 39,276 | [
-1
] |
39,277 | input.lisp | Akah_cl-pkmn/src/input.lisp | (in-package #:pkmn)
(defun handle-key-start-menu ()
"press any key to move past start menu"
(setf *state* :overworld)
(print-debug :debug (format nil "set state to ~a" *state*)))
(defun handle-key-overworld (keysym)
(unless (> block-time 1)
(setf block-time 20)
(case (sdl2:scancode keysym)
(:sca... | 2,000 | Common Lisp | .lisp | 57 | 30.491228 | 66 | 0.627066 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | a867f2edfc8deee25aab48836eddeffa853ab09c57112ee695e8cbbc2ac947ed | 39,277 | [
-1
] |
39,278 | structs.lisp | Akah_cl-pkmn/src/data/structs.lisp | (in-package #:pkmn)
;;; battle
(defstruct pkmn
name ; string
stats ;'stats
type ; string?
moves ; list of 'move
level ; int
exp) ; int
(defstruct stats
;; all ints
hp
atk
def
sp-atk
sp-def
speed
evasiveness
accuracy)
(defstruct move
name ; string
type ; string?
pp-curr... | 473 | Common Lisp | .lisp | 34 | 11.235294 | 23 | 0.655963 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 4862a82719039f99d2170db0d6069e2ada55b59de610812a91bef397a4ccf25e | 39,278 | [
-1
] |
39,279 | repl.lisp | Akah_cl-pkmn/src/utils/repl.lisp | (in-package #:pkmn)
(defun repl ()
(format t "~s " 'PKMN-REPL>)
(format t "~a~%" (eval (read)))
(repl))
| 111 | Common Lisp | .lisp | 5 | 19.8 | 33 | 0.552381 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | c26ea598aa3ddff4164271583cb94104a25eda58ef8b729b3f125c96c71a8778 | 39,279 | [
-1
] |
39,280 | battle.lisp | Akah_cl-pkmn/src/battle/battle.lisp | (in-package #:pkmn)
(defparameter *kill* nil)
;;===================================PRINT==========================================
(defun print-battle-status (player enemy)
(write-line "--------------------------------------------------")
(format t "~% ~A: ~Dhp"
(pkmn-name player)
(stats-hp (pkmn-stats pla... | 4,085 | Common Lisp | .lisp | 107 | 34.186916 | 102 | 0.589218 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 4733f96a02f4f67bbc08f08ac96cb3801113d90b4bf9d607cd9a88212312b049 | 39,280 | [
-1
] |
39,281 | effectiveness.lisp | Akah_cl-pkmn/src/battle/effectiveness.lisp | (in-package #:pkmn)
;;make assoc-array of types numbered
;;number represents order in the array of effectivenesses
(defparameter *types* '(normal fire water electric grass ice fighting poison ground
flying psychic bug rock ghost dragon dark steel))
(defparameter *table* '(;no fr wa el gr ic fg po gd fl ps bg ro g... | 2,251 | Common Lisp | .lisp | 48 | 43.145833 | 83 | 0.626424 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 44519eb01ea69fa0f0a1f63ff7a4e6b7a4ba9ba987ea5fb4ab8b0adf7dc36a19 | 39,281 | [
-1
] |
39,282 | draw-functions.lisp | Akah_cl-pkmn/src/graphics/draw-functions.lisp | (in-package #:pkmn)
(defun render-clear (renderer)
"Reset the screen to white"
(sdl2:set-render-draw-color renderer 255 255 255 0)
(sdl2:render-clear renderer))
(defun draw (renderer)
"Debug only; draw red cube to represent player"
(sdl2:set-render-draw-color renderer 255 0 0 0)
(sdl2:render-fill-rect
... | 5,728 | Common Lisp | .lisp | 136 | 38.198529 | 84 | 0.664155 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 41a248a428ead1fd12686a068890d61f2cbdf544b6bc27d6966886ff3aa6a25d | 39,282 | [
-1
] |
39,283 | font.lisp | Akah_cl-pkmn/src/graphics/font.lisp | ;;;; font.lisp
(in-package #:pkmn)
;; f(string) => [1D coordinates matching font image]
;; * take string input
;; * foreach char get location on image
;; * return list of char-locations with source as render-items to be renderered
;; in renderer.
;; 33 means space is -1, not shown in text image but when -1; need to... | 634 | Common Lisp | .lisp | 15 | 39.466667 | 79 | 0.694309 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | f498532fcd5664aafead7254407ab5a1fbb24362b30991e84dd9d6750e268976 | 39,283 | [
-1
] |
39,284 | game.lisp | Akah_cl-pkmn/src/graphics/game.lisp | ;;;; game.lisp
(in-package #:pkmn)
(defparameter menu-options '("pokedex"
"pokemon"
"pack"
"pokegear"
"player"
"save"
"option"
"exit"))
(defmacro with-image-init (&body body)
`(progn
(sdl2-image:init '(:png))
(print-debug :info "Initialising sdl2:im... | 3,358 | Common Lisp | .lisp | 101 | 28.60396 | 81 | 0.644136 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 37b29b0f4f1902a26f9d393ba8bb41fcdb514370a34011659943c9e39cde1dfb | 39,284 | [
-1
] |
39,285 | pkmn.asd | Akah_cl-pkmn/pkmn.asd | ;;;; pkmn.asd
(asdf:defsystem #:pkmn
:description "pokemon clone written in common lisp"
:author "Akah"
:license "gplv3.0"
;; TODO increment version number on each build
:version "0.0.1.0"
:serial t
:build-operation "asdf:program-op"
:entry-point "pkmn:main"
:depends-on (#:sdl2
... | 846 | Common Lisp | .asd | 25 | 28.68 | 72 | 0.622711 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | 10b33dfe4225651fd5dd82c6d7134e3552e0c4c92cd296309784d7cedac0179b | 39,285 | [
-1
] |
39,287 | Makefile | Akah_cl-pkmn/Makefile | build:
sbcl --load pkmn.asd \
--eval '(ql:quickload :pkmn)' \
--eval '(asdf:make :pkmn)' \
--eval '(quit)'
clean:
rm -f pkmn
rm -rf ./*.fasl
| 150 | Common Lisp | .l | 8 | 16.625 | 33 | 0.584507 | Akah/cl-pkmn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:46:04 AM (Europe/Amsterdam) | b31020b90388427dfdc4fb3d3200162c1cd8530f787b89243f9e5ccfa00c9986 | 39,287 | [
-1
] |
39,328 | spotlight.lisp | conjunctive_spotlight/src/spotlight.lisp | (defpackage #:spotlight
(:nicknames #:spotlight #:sl)
(:use #:cl)
(:import-from #:alexandria
#:compose
#:copy-hash-table)
(:export #:lens
#:id-setter
#:const-setter
#:id
#:focus
#:over
#:put
#:units
... | 9,084 | Common Lisp | .lisp | 265 | 28.026415 | 77 | 0.62631 | conjunctive/spotlight | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:46:12 AM (Europe/Amsterdam) | 4f5cbd7da43a41f3adc82d28490a0697f6452fdf1b9d184617b618af3d115fef | 39,328 | [
-1
] |
39,329 | spotlight.lisp | conjunctive_spotlight/t/spotlight.lisp | (defpackage #:spotlight-test
(:use #:cl
#:prove)
(:import-from #:alexandria
#:compose
#:copy-hash-table
#:alist-hash-table
#:hash-table-alist)
(:import-from #:spotlight
#:lens
#:id-setter
#:cons... | 8,260 | Common Lisp | .lisp | 221 | 30.067873 | 102 | 0.523726 | conjunctive/spotlight | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:46:12 AM (Europe/Amsterdam) | 941c822b6002ccf5137ed0daf0bc308e665be31d2b50f957ec6ddd4218227750 | 39,329 | [
-1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.