d

So I'm arguing with my friend who claims that a compiler like GCC can detect a pure function automatically without any type information. I doubt that. Languages like D or Haskell have purity in their type systems and a programmer explicitly defines what function is pure or not. A pure function has no side effects and can therefore very easily be parallelized. So the question is: Is this all necessary or not? Could a compiler detect purity, without any meta or type information, just by assuming that anything that does IO or accesses global variables automatically is not pure? Sure, you can

How to call C++ function from D program? I still can't understand how to do it. What commands do I need to execute? I use dmd in Fedora. Vlad Simplest example I can think of, if you're calling C functions: $ cat a.c int f(int a, int b){ return a + b + 42; } $ cat a.di extern (C): int f(int, int); $ cat b.d import std.stdio; import a; void main(){ writeln( f( 100, 1000) ); } $ gcc -c a.c $ dmd b.d a.o $ ./b 1142 $ If you're using shared objects, you could so something like: $ cat sdltest.di module sdltest; extern (C): struct SDL_version{ ubyte major; ubyte minor; ubyte patch; } SDL_version *

Background: I'm trying to create a pure D language implementation of functionality that's roughly equivalent to C's memchr but uses arrays and indices instead of pointers. The reason is so that std.string will work with compile time function evaluation. For those of you unfamiliar w/ D, functions can be evaluated at compile time if certain restrictions are met. One restriction is that they can't use pointers. Another is that they can't call C functions or use inline assembly language. Having the string library work at compile time is useful for some compile time code gen hacks. Question: How

My question is sort of like this question but I have more constraints: I know the document's are reasonably sane they are very regular (they all came from the same source I want about 99% of the visible text about 99% of what is viable at all is text (they are more or less RTF converted to HTML) I don't care about formatting or even paragraph breaks. Are there any tools set up to do this or am I better off just breaking out RegexBuddy and C#? I'm open to command line or batch processing tools as well as C/C#/D libraries. SLaks You need to use the HTML Agility Pack . You probably want to find

I hear that the D language has powerful metaprogramming features for executing functions at compile time. That sounds very exciting, but I find it difficult to think of practical examples of things that are hard to accomplish without them. Can anyone give some examples of situations where D's metaprogramming features comes in very handy? One really cool and practical usage of compile time function execution is for generating code at compile time, possibly from config files, or maybe scripts. Here's a simple example of processing a file at compile time. main.d string make_ints(string s) {

I'm looking to submit a patch to the D programming language standard library that will allow much of std.math to be evaluated at compile time using the compile-time function evaluation facilities of the language. Compile-time function evaluation has several limitations, the most important ones being: You can't use assembly language. You can't call C code or code for which the source is otherwise unavailable. Several std.math functions violate these and compile-time versions need to be written. Where can I get information on good algorithms for computing things such as logarithms, exponents,

I like some features of D, but would be interested if they come with a runtime penalty? To compare, I implemented a simple program that computes scalar products of many short vectors both in C++ and in D. The result is surprising: D: 18.9 s [see below for final runtime] C++: 3.8 s Is C++ really almost five times as fast or did I make a mistake in the D program? I compiled C++ with g++ -O3 (gcc-snapshot 2011-02-19) and D with dmd -O (dmd 2.052) on a moderate recent linux desktop. The results are reproducible over several runs and standard deviations negligible. Here the C++ program: #include