| #![feature(plugin)] | |
| #![plugin(dynamic_gen)] | |
| extern crate dynamic; | |
| use dynamic::Object; | |
| #[protocol] | |
| trait Pet { | |
| fn speak(&self) -> String; | |
| } |
I am currently dealing with a lot of libraries at work. Both third party as well as libraries written or being currently in process of being written by me. I absolutely love writing and working with libraries. Especially if they present or bring me to either a new or different approach to solve a problem. Or at least provide a different view.
Over time I noticed however that quite regulary we had to decide that we cannot use a third party library. Often it is the usual reason.
| This is a brief comment on this article on API design principles: | |
| https://gist.github.com/vurtun/192cac1f1818417d7b4067d60e4fe921 | |
| I've called that style of API a coroutine, iterator, state machine, push/pull or client/server API | |
| depending on what seems most appropriate for the context, but they are all variants of the same idea. | |
| It's particularly superior in many cases as an alternative to callback-based APIs, which are the more | |
| common way of providing this kind of fine-grained interleaving between library code and user code. | |
| Callbacks can still be superior in usability for context-free operations like memory allocation, |
dataflow, a paradigm so closely related to FRP it might actually be indistinguishable.
much of this section is plagiarised from This Stackoverflow Answer:
| function doStartProcess(programWithParams) | |
| local psCmd = '"powershell.exe -Command "Start-Process cmd " -ArgumentList "/c", "\'' .. programWithParams .. '\'" -Verb RunAs -Wait"' | |
| --print (psCmd) | |
| os.execute(psCmd) | |
| end |
| -- Metatables acts as helpers to tables | |
| -- https://www.lua.org/pil/13.html | |
| -- Meta Methods: | |
| -- __index | |
| -- __newindex | |
| -- Operator examples: __add, __sub, __mul, __concat | |
| local meta = {} |
A list of simple tasks to perform when learning or evaluating a new language. Each of these should be able to be completed in a few hours, and will help to get the feel of the language and its standard libraries. A well-rounded set of evaluation tasks will help ensure all parts of the language are exercised. You might also write some tests to demonstrate implementation correctness.
Type system is a construction for guarantees safely in a language, though exist many other aplications like metaprogramming... It's means that i can writes a program but with a safe way, sure it's is perfect why it's solve many problems that programmers has after of compilation. The main idea that i can encode and represent a subset of solutions with a safe type system and better maybe the type can help me represent that.
Ok it's mean i have a safe type system and i could represent my types of data..... Ok sure...., but no... limited type system have a weak power of abstraction(no i am not talking about c++ but yes a little part of the language).
Let's go represent a pair: Pair is a tuple of the two values like (P x y), where x and y are values, in this discussion the values x and y can be encode a T type and a Tuple T type.
| --[[ | |
| The following example illustrates string interpolation [1] | |
| by way of a preprocessor that runs as a customer searcher | |
| function in package.loaders. | |
| Tested in Lua 5.2.0-beta. | |
| Depends on | |
| file_slurp https://gist.github.com/1325400 (for loading files simply) | |
| luabalanced https://github.com/davidm/lua-balanced (for Lua parsing) |
| # fzf from https://github.com/junegunn/fzf | |
| # diff-so-fancy from https://github.com/so-fancy/diff-so-fancy | |
| gcop() { | |
| git log \ | |
| --reverse \ | |
| --color=always \ | |
| --format="%C(cyan)%h %C(blue)%ar%C(auto)%d% C(yellow)%s%+b %C(magenta)%ae" "$@" | | |
| fzf -i -e +s \ | |
| --reverse \ |